[ap draw] drawing manager

now in ap, there are no NOGRAPHCIS macro

Author: robluo

vpr/src/analytical_place/analytical_draw_manager.cpp

@@ -0,0 +1,40 @@
+/**
+ * @file
+ * @author  Yulang (Robert) Luo
+ * @date    October 2025
+ * @brief   The definitions of the Analytical Draw Manager class which is used
+ *          to handle graphics updates during analytical placement.
+ */
+
+#include "analytical_draw_manager.h"
+#include "vpr_types.h"
+
+#ifndef NO_GRAPHICS
+#include "draw.h"
+#include "draw_global.h"
+#include "partial_placement.h"
+#endif
+
+AnalyticalDrawManager::AnalyticalDrawManager(const PartialPlacement& p_placement) {
+#ifndef NO_GRAPHICS
+    // Set the analytical placement reference in draw state
+    get_draw_state_vars()->set_ap_partial_placement_ref(p_placement);
+#else
+    (void)p_placement;
+#endif
+}
+
+AnalyticalDrawManager::~AnalyticalDrawManager() {
+#ifndef NO_GRAPHICS
+    // Clear the analytical placement reference in draw state
+    get_draw_state_vars()->clear_ap_partial_placement_ref();
+#endif
+}
+
+void AnalyticalDrawManager::update_graphics(const std::string& msg) {
+#ifndef NO_GRAPHICS
+    update_screen(ScreenUpdatePriority::MAJOR, msg.c_str(), ANALYTICAL_PLACEMENT, nullptr);
+#else
+    (void)msg;
+#endif
+}

vpr/src/analytical_place/analytical_draw_manager.h

@@ -0,0 +1,41 @@
+#pragma once
+/**
+ * @file
+ * @author  Yulang (Robert) Luo
+ * @date    October 2025
+ * @brief   The decalarations of the Analytical Draw Manager class which is used
+ *          to handle graphics updates during analytical placement.
+ */
+
+#include <string>
+
+// Forward declarations
+class PartialPlacement;
+
+/**
+ * @class AnalyticalDrawManager
+ * @brief Manages graphics updates during analytical placement operations.
+ *
+ * This class provides a clean interface for updating the screen during
+ * analytical placement without requiring the placement code to be littered
+ * with NO_GRAPHICS conditional compilation directives.
+ */
+class AnalyticalDrawManager {
+public:
+    /**
+     * @brief Constructor initializes the draw manager with a reference to the
+     *        current partial placement.
+     */
+    explicit AnalyticalDrawManager(const PartialPlacement& p_placement);
+
+    /**
+     * @brief Destructor cleans up the reference in the draw state.
+     */
+    ~AnalyticalDrawManager();
+
+    /**
+     * @brief Update screen with current analytical placement state
+     * @param msg A message to display with the update
+     */
+    void update_graphics(const std::string& msg);
+};

vpr/src/analytical_place/global_placer.cpp

@@ -11,6 +11,7 @@
 #include <limits>
 #include <memory>
 #include <vector>
+#include "analytical_draw_manager.h"
 #include "PreClusterTimingManager.h"
 #include "analytical_solver.h"
 #include "ap_flow_enums.h"
@@ -356,10 +357,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
+    // Initialize graphics for analytical placement, setting the reference in
+    // the draw state.
+    AnalyticalDrawManager draw_manager(p_placement);
+    
     // Run the global placer.
     for (size_t i = 0; i < max_num_iterations_; i++) {
         float iter_start_time = runtime_timer.elapsed_sec();
@@ -369,22 +370,18 @@ 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
+        
+        // Update graphics after analytical solver
+        draw_manager.update_graphics("Iteration " + std::to_string(i) + " After Solver");
 
         // 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
+        
+        // Update graphics after legalizer
+        draw_manager.update_graphics("Iteration " + std::to_string(i) + " After Legalizer");
 
         // Perform a timing update
         float timing_update_start_time = runtime_timer.elapsed_sec();
@@ -440,8 +437,6 @@ 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
@@ -470,13 +465,7 @@ 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

@@ -324,7 +324,6 @@ void update_screen(ScreenUpdatePriority priority, const char* msg, enum pic_type
         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.

vpr/src/draw/draw.h

@@ -52,7 +52,18 @@ void update_screen(ScreenUpdatePriority priority, const char* msg, enum pic_type
  */
 void init_draw_coords(float clb_width, const BlkLocRegistry& blk_loc_registry);
 
+/**
+* @brief Set the intial_world ezgl::rectangle for analytical placement
+* 
+* This function sets graphic initial dimensions so there are no gaps between blocks
+*/
 void set_initial_world_ap();
+
+/**
+ * @brief Set the intial_world ezgl::rectangle for default
+ *
+ * This function sets graphic initial dimensions so there are gaps between blocks
+ */
 void set_initial_world();
 
 /* Sets the static show_graphics and gr_automode variables to the    *

vpr/src/draw/draw_basic.cpp

@@ -205,11 +205,7 @@ void draw_analytical_place(ezgl::renderer* g) {
 
         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;
-
+                if (device_ctx.grid.is_root_location({x, y, layer}) == false) continue;
                 t_physical_tile_type_ptr type = device_ctx.grid.get_physical_type({x, y, layer});
                 if (type->capacity == 0) continue;
 

vpr/src/draw/draw_basic.h

@@ -29,6 +29,9 @@
  * Blocks are drawn in layer order (so that semi-transparent blocks/grids render well)*/
 void drawplace(ezgl::renderer* g);
 
+/** This function draws the analytical placement from the PartialPlacement object, it
+ *  also draws the architecture grid and the blocks from device_ctx.
+ */
 void draw_analytical_place(ezgl::renderer* g);
 
 /** This routine draws the nets on the placement.  The nets have not