[draw ap] ap draw working with the rest of the draw

No more segfault when clicking.
Added after solve and after legalization draw.

Author: robluo

vpr/src/analytical_place/global_placer.cpp

@@ -19,6 +19,9 @@
 #include "atom_netlist.h"
 #include "device_grid.h"
 #include "draw.h"
+#ifndef NO_GRAPHICS
+#include "draw_global.h"
+#endif
 #include "flat_placement_bins.h"
 #include "flat_placement_density_manager.h"
 #include "globals.h"
@@ -353,6 +356,10 @@ PartialPlacement SimPLGlobalPlacer::place() {
     PartialPlacement best_p_placement(ap_netlist_);
     double best_ub_hpwl = std::numeric_limits<double>::max();
 
+#ifndef NO_GRAPHICS
+    get_draw_state_vars()->set_ap_partial_placement_ref(p_placement);
+    update_screen(ScreenUpdatePriority::MAJOR, "AP starts", ANALYTICAL_PLACEMENT, nullptr);
+#endif
     // Run the global placer.
     for (size_t i = 0; i < max_num_iterations_; i++) {
         float iter_start_time = runtime_timer.elapsed_sec();
@@ -362,12 +369,22 @@ PartialPlacement SimPLGlobalPlacer::place() {
         solver_->solve(i, p_placement);
         float solver_end_time = runtime_timer.elapsed_sec();
         double lb_hpwl = p_placement.get_hpwl(ap_netlist_);
+#ifndef NO_GRAPHICS
+        // Per iteration analytical solve display
+        std::string iter_msg = vtr::string_fmt("AP Iteration %zu after analytical solve", i);
+        update_screen(ScreenUpdatePriority::MAJOR, iter_msg.c_str(), ANALYTICAL_PLACEMENT, nullptr);
+#endif
 
         // Run the legalizer.
         float legalizer_start_time = runtime_timer.elapsed_sec();
         partial_legalizer_->legalize(p_placement);
         float legalizer_end_time = runtime_timer.elapsed_sec();
         double ub_hpwl = p_placement.get_hpwl(ap_netlist_);
+#ifndef NO_GRAPHICS
+        // Per iteration legalized display
+        iter_msg = vtr::string_fmt("AP Iteration %zu after partial legalization", i);
+        update_screen(ScreenUpdatePriority::MAJOR, iter_msg.c_str(), ANALYTICAL_PLACEMENT, nullptr);
+#endif
 
         // Perform a timing update
         float timing_update_start_time = runtime_timer.elapsed_sec();
@@ -423,6 +440,8 @@ PartialPlacement SimPLGlobalPlacer::place() {
 
         if (hpwl_relative_gap < target_hpwl_relative_gap_)
             break;
+
+
     }
 
     // Update the setup slacks. This is performed down here (as well as being
@@ -451,7 +470,13 @@ PartialPlacement SimPLGlobalPlacer::place() {
                           *density_manager_,
                           pre_cluster_timing_manager_);
 
+
+#ifndef NO_GRAPHICS
+    // Final display of the last iteration's placement
+    get_draw_state_vars()->set_ap_partial_placement_ref(p_placement);
     update_screen(ScreenUpdatePriority::MAJOR, "Global Placement Complete", ANALYTICAL_PLACEMENT, nullptr);
+    get_draw_state_vars()->clear_ap_partial_placement_ref();
+#endif
     // Return the placement from the final iteration.
     return best_p_placement;
 }

vpr/src/draw/draw.cpp

@@ -16,6 +16,7 @@
 #include <cstring>
 #include <cmath>
 #include "draw.h"
+#include "draw_types.h"
 #include "timing_info.h"
 #include "physical_types.h"
 
@@ -519,7 +520,19 @@ void set_initial_world() {
 }
 
 void set_initial_world_ap() {
-    initial_world = ezgl::rectangle({-1, -1}, {1, 1});
+    constexpr float VISIBLE_MARGIN = 0.01f;
+    const DeviceContext& device_ctx = g_vpr_ctx.device();
+
+    const size_t grid_w = device_ctx.grid.width();
+    const size_t grid_h = device_ctx.grid.height();
+
+
+    float draw_width = static_cast<float>(grid_w);
+    float draw_height = static_cast<float>(grid_h);
+
+    initial_world = ezgl::rectangle(
+        {-VISIBLE_MARGIN * draw_width, -VISIBLE_MARGIN * draw_height},
+        {(1.f + VISIBLE_MARGIN) * draw_width, (1.f + VISIBLE_MARGIN) * draw_height});
 }
 
 #ifndef NO_GRAPHICS
@@ -648,6 +661,11 @@ void act_on_mouse_press(ezgl::application* app, GdkEventButton* event, double x,
              * fanins and fanouts are highlighted when you click on a block      *
              * attached to them.                                                 */
 
+            if (get_draw_state_vars()->pic_on_screen == ANALYTICAL_PLACEMENT) {
+                // No selection in analytical placement mode yet
+                return;
+            }
+
             /* Control + mouse click to select multiple nets. */
             if (!(event->state & GDK_CONTROL_MASK))
                 deselect_all();

vpr/src/draw/draw_basic.cpp

@@ -12,11 +12,9 @@
 
 #include "physical_types_util.h"
 #include "vtr_assert.h"
-#include "vtr_ndoffsetmatrix.h"
 #include "vtr_color_map.h"
 
 #include "vpr_utils.h"
-#include "vpr_error.h"
 
 #include "globals.h"
 #include "draw_color.h"
@@ -29,6 +27,7 @@
 #include "move_utils.h"
 #include "route_export.h"
 #include "tatum/report/TimingPathCollector.hpp"
+#include "partial_placement.h"
 
 //To process key presses we need the X11 keysym definitions,
 //which are unavailable when building with MINGW
@@ -194,12 +193,57 @@ 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();
+    // Draw a tightly packed view of the device grid using only device context info.
+    t_draw_state* draw_state = get_draw_state_vars();
+    const DeviceContext& device_ctx = g_vpr_ctx.device();
+
     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);
+
+    int total_layers = device_ctx.grid.get_num_layers();
+    for (int layer = 0; layer < total_layers; ++layer) {
+        const auto& layer_disp = draw_state->draw_layer_display[layer];
+        if (!layer_disp.visible) continue;
+
+        for (int x = 0; x < (int)device_ctx.grid.width(); ++x) {
+            for (int y = 0; y < (int)device_ctx.grid.height(); ++y) {
+                // Only draw at the root of a non-unit tile
+                int w_off = device_ctx.grid.get_width_offset({x, y, layer});
+                int h_off = device_ctx.grid.get_height_offset({x, y, layer});
+                if (w_off > 0 || h_off > 0) continue;
+
+                t_physical_tile_type_ptr type = device_ctx.grid.get_physical_type({x, y, layer});
+                if (type->capacity == 0) continue;
+
+                ezgl::point2d bl{static_cast<double>(x), static_cast<double>(y)};
+                ezgl::point2d tr{static_cast<double>(x + type->width), static_cast<double>(y + type->height)};
+
+                ezgl::color fill_color = get_block_type_color(type);
+                g->set_color(fill_color, layer_disp.alpha);
+                g->fill_rectangle(bl, tr);
+
+                if (draw_state->draw_block_outlines) {
+                    g->set_color(ezgl::BLACK, layer_disp.alpha);
+                    g->draw_rectangle(bl, tr);
+                }
+            }
+        }
+    }
+
+    const double half_size = 0.05;
+
+    const PartialPlacement* ap_pp = draw_state->get_ap_partial_placement_ref();
+    // The reference should be set in the beginning of analytial placement.
+    VTR_ASSERT(ap_pp != nullptr);
+    for (const auto& [blk_id, x] : ap_pp->block_x_locs.pairs()) {
+        double y = ap_pp->block_y_locs[blk_id];
+
+        ezgl::point2d bl{x - half_size, y - half_size};
+        ezgl::point2d tr{x + half_size, y + half_size};
+
+        g->set_color(ezgl::BLACK);
+        g->fill_rectangle(bl, tr);
+    }
 }
 
 /* This routine draws the nets on the placement.  The nets have not *

vpr/src/draw/draw_types.h

@@ -157,6 +157,8 @@ struct t_draw_layer_display {
     int alpha = 255;
 };
 
+struct PartialPlacement;
+
 /**
  * @brief Structure used to store variables related to highlighting/drawing
  * 
@@ -396,6 +398,19 @@ struct t_draw_state {
      * @brief Stores a reference to NoC link bandwidth utilization to be used in the graphics codes.
      */
     std::optional<std::reference_wrapper<const vtr::vector<NocLinkId, double>>> noc_link_bandwidth_usages_ref_;
+
+    /**
+     * @brief Stores a temporary reference to the Analytical Placement partial placement (best placement).
+     * @details This is set by the AP global placer just before drawing and cleared immediately after.
+     *          Only a reference is stored to avoid copying and lifetime issues.
+     */
+    std::optional<std::reference_wrapper<const PartialPlacement>> ap_partial_placement_ref_;
+
+public:
+    // Set/clear/get the AP partial placement reference used during AP drawing
+    void set_ap_partial_placement_ref(const PartialPlacement& p) { ap_partial_placement_ref_ = std::cref(p); }
+    void clear_ap_partial_placement_ref() { ap_partial_placement_ref_.reset(); }
+    const PartialPlacement* get_ap_partial_placement_ref() const { return ap_partial_placement_ref_ ? &ap_partial_placement_ref_->get() : nullptr; }
 };
 
 /* For each cluster type, this structure stores drawing