draw floorplan regions for 3d architectures

soheilshahrouz · soheilshahrouz · commit 2d1de0c793a7 · 2024-06-26T17:30:32.000-04:00
diff --git a/vpr/src/base/partition_region.cpp b/vpr/src/base/partition_region.cpp
@@ -86,18 +86,17 @@ void print_partition_region(FILE* fp, const PartitionRegion& pr) {
 }
 
 const PartitionRegion& get_device_partition_region() {
-    // the device partition region is constructed
+    // the device partition region is initialized the first time this function is called
     static PartitionRegion device_pr;
 
-    const auto& grid_ctx = g_vpr_ctx.device().grid;
+    const auto& grid = g_vpr_ctx.device().grid;
 
-    if (grid_ctx.grid_size() == 0) {
-        // TODO: error message
-    }
+    // this function is supposed to be called when the grid is constructed
+    VTR_ASSERT_SAFE(grid.grid_size() != 0);
 
-    const int n_layers = grid_ctx.get_num_layers();
-    const int width = (int)grid_ctx.width();
-    const int height = (int)grid_ctx.height();
+    const int n_layers = grid.get_num_layers();
+    const int width = static_cast<int>(grid.width());
+    const int height = static_cast<int>(grid.height());
 
     if (device_pr.empty()) {
         Region device_region(0, 0, width - 1, height - 1, 0, n_layers - 1);
diff --git a/vpr/src/base/vpr_context.h b/vpr/src/base/vpr_context.h
@@ -523,11 +523,20 @@ struct FloorplanningContext : public Context {
     /**
      * @brief Floorplanning constraints in the compressed grid coordinate system.
      *
+     * Indexing -->  [0..grid.num_layers-1][0..numClusters-1]
+     *
      * Each clustered block has a logical type with a corresponding compressed grid.
      * Compressed floorplanning constraints are calculated by translating the grid locations
      * of floorplanning regions to compressed grid locations. To ensure regions do not enlarge:
      * - The bottom left corner is rounded up to the nearest compressed location.
      * - The top right corner is rounded down to the nearest compressed location.
+     *
+     * When the floorplanning constraint spans across multiple layers, a compressed
+     * constraints is created for each a layer that the original constraint includes.
+     * This is because blocks of the same type might have different (x, y) locations
+     * in different layers, and as result, their compressed locations in each layer
+     * may correspond to a different physical (x, y) location.
+     *
      */
     std::vector<vtr::vector<ClusterBlockId, PartitionRegion>> compressed_cluster_constraints;
 
diff --git a/vpr/src/draw/draw_floorplanning.cpp b/vpr/src/draw/draw_floorplanning.cpp
@@ -45,7 +45,10 @@
 #        include <X11/keysym.h>
 #    endif
 
-static void draw_internal_pb(const ClusterBlockId clb_index, t_pb* current_pb, const t_pb* pb_to_draw, const ezgl::rectangle& parent_bbox, const t_logical_block_type_ptr type, ezgl::color color, ezgl::renderer* g);
+static void draw_internal_pb(const ClusterBlockId clb_index, t_pb* current_pb,
+                             const t_pb* pb_to_draw, const ezgl::rectangle& parent_bbox,
+                             const t_logical_block_type_ptr type, ezgl::color color,
+                             ezgl::renderer* g);
 
 const std::vector<ezgl::color> kelly_max_contrast_colors_no_black = {
     //ezgl::color(242, 243, 244), //white: skip white since it doesn't contrast well with VPR's light background
@@ -83,63 +86,65 @@ static void highlight_partition(ezgl::renderer* g, int partitionID, int alpha) {
     auto& 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();
 
     const auto& partition = constraints.get_partition((PartitionId)partitionID);
     const auto& partition_region = partition.get_part_region();
     const auto& regions = partition_region.get_regions();
 
     bool name_drawn = false;
     ezgl::color partition_color = kelly_max_contrast_colors_no_black[partitionID % (kelly_max_contrast_colors_no_black.size())];
-    g->set_color(partition_color, alpha);
 
-    // The units of space in the constraints xml file will be refered to as "tile units"
-    // The units of space that'll be used by ezgl to draw will be refered to as "on screen units"
+    // The units of space in the constraints xml file will be referred to as "tile units"
+    // The units of space that'll be used by ezgl to draw will be referred to as "on screen units"
 
     // Find the coordinates of the region by retrieving from the xml file
     // which tiles are at the corner of the region, then translate that to on
     // the on screen units for ezgl to use.
 
     for (int region = 0; (size_t)region < regions.size(); region++) {
         const vtr::Rect<int>& reg_coord = regions[region].get_rect();
-        const auto [layer_begin, layer_end] = regions[region].get_layer_range();
+        const auto [layer_low, layer_high] = regions[region].get_layer_range();
 
-        //TODO: 0 should be replaced with the actual z value of the region when graph is 3D
-        ezgl::rectangle top_right = draw_coords->get_absolute_clb_bbox(layer_begin,
-                                                                       reg_coord.xmax(),
-                                                                       reg_coord.ymax(),
-                                                                       0);
-        ezgl::rectangle bottom_left = draw_coords->get_absolute_clb_bbox(layer_end,
-                                                                         reg_coord.xmin(),
-                                                                         reg_coord.ymin(),
-                                                                         0);
+        for (int layer = layer_low; layer <= layer_high; layer++) {
+            if (!draw_state->draw_layer_display[layer].visible) {
+                continue;
+            }
 
-        ezgl::rectangle on_screen_rect(bottom_left.bottom_left(), top_right.top_right());
+            int alpha_layer_part = alpha * draw_state->draw_layer_display[layer].alpha / 255;
+            g->set_color(partition_color, alpha_layer_part);
 
-        if (!name_drawn) {
-            g->set_font_size(10);
-            const std::string& partition_name = partition.get_name();
+            ezgl::rectangle top_right = draw_coords->get_absolute_clb_bbox(layer, reg_coord.xmax(), reg_coord.ymax(), 0);
+            ezgl::rectangle bottom_left = draw_coords->get_absolute_clb_bbox(layer, reg_coord.xmin(), reg_coord.ymin(), 0);
 
-            g->set_color(partition_color, 230);
+            ezgl::rectangle on_screen_rect(bottom_left.bottom_left(), top_right.top_right());
 
-            g->draw_text(
-                on_screen_rect.center(),
-                partition_name,
-                on_screen_rect.width() - 10,
-                on_screen_rect.height() - 10);
+            if (!name_drawn) {
+                g->set_font_size(10);
+                const std::string& partition_name = partition.get_name();
 
-            name_drawn = true;
+                g->set_color(partition_color, 230);
 
-            g->set_color(partition_color, alpha);
-        }
+                g->draw_text(
+                    on_screen_rect.center(),
+                    partition_name,
+                    on_screen_rect.width() - 10,
+                    on_screen_rect.height() - 10);
 
-        g->fill_rectangle(on_screen_rect);
+                name_drawn = true;
+
+                g->set_color(partition_color, alpha);
+            }
+
+            g->fill_rectangle(on_screen_rect);
+        }
     }
 }
 
 //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();
-    auto constraints = floorplanning_ctx.constraints;
+    const auto& constraints = floorplanning_ctx.constraints;
     auto num_partitions = constraints.get_num_partitions();
 
     //keeps track of what alpha level each partition is
@@ -155,18 +160,18 @@ void highlight_all_regions(ezgl::renderer* g) {
     }
 }
 
-// Draws atoms that're constrained to a partition in the colour of their respective partition.
+// 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();
-    auto constraints = floorplanning_ctx.constraints;
-    auto num_partitions = constraints.get_num_partitions();
+    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();
 
     for (int partitionID = 0; partitionID < num_partitions; partitionID++) {
         auto atoms = constraints.get_part_atoms((PartitionId)partitionID);
 
-        for (const auto atom_id : atoms) {
+        for (const AtomBlockId atom_id : atoms) {
             if (atom_ctx.lookup.atom_pb(atom_id) != nullptr) {
                 const t_pb* pb = atom_ctx.lookup.atom_pb(atom_id);
                 auto color = kelly_max_contrast_colors_no_black[partitionID % (kelly_max_contrast_colors_no_black.size())];
@@ -180,7 +185,12 @@ void draw_constrained_atoms(ezgl::renderer* g) {
 }
 
 //Recursive function to find where the constrained atom is and draws it
-static void draw_internal_pb(const ClusterBlockId clb_index, t_pb* current_pb, const t_pb* pb_to_draw, const ezgl::rectangle& parent_bbox, const t_logical_block_type_ptr type, ezgl::color color, ezgl::renderer* g) {
+static void draw_internal_pb(const ClusterBlockId clb_index,
+                             t_pb* current_pb,
+                             const t_pb* pb_to_draw,
+                             const ezgl::rectangle& parent_bbox,
+                             const t_logical_block_type_ptr type,
+                             ezgl::color color, ezgl::renderer* g) {
     t_draw_coords* draw_coords = get_draw_coords_vars();
     t_draw_state* draw_state = get_draw_state_vars();
 
@@ -300,8 +310,8 @@ void highlight_selected_partition(GtkWidget* widget) {
 static GtkTreeModel* create_and_fill_model() {
     auto& atom_ctx = g_vpr_ctx.atom();
     auto& floorplanning_ctx = g_vpr_ctx.floorplanning();
-    auto constraints = floorplanning_ctx.constraints;
-    auto num_partitions = constraints.get_num_partitions();
+    const auto& constraints = floorplanning_ctx.constraints;
+    int num_partitions = constraints.get_num_partitions();
 
     GtkTreeStore* store = gtk_tree_store_new(NUM_COLS, G_TYPE_STRING);
 
@@ -318,7 +328,7 @@ static GtkTreeModel* create_and_fill_model() {
                            COL_NAME, partition_name.c_str(),
                            -1);
 
-        for (auto const_atom : atoms) {
+        for (AtomBlockId const_atom : atoms) {
             std::string atom_name = (atom_ctx.lookup.atom_pb(const_atom))->name;
             gtk_tree_store_append(store, &child_iter, &iter);
             gtk_tree_store_set(store, &child_iter,
diff --git a/vpr/src/draw/draw_noc.cpp b/vpr/src/draw/draw_noc.cpp
@@ -201,7 +201,11 @@ void draw_noc_connection_marker(ezgl::renderer* g, const vtr::vector<NocRouterId
 /*
  * This function draws the links within the noc. So based on a given noc topology, this function draws the links that connect the routers in the noc together.
  */
-void draw_noc_links(ezgl::renderer* g, t_logical_block_type_ptr noc_router_logical_block_type, vtr::vector<NocLinkId, ezgl::color>& noc_link_colors, ezgl::rectangle noc_connection_marker_bbox, const vtr::vector<NocLinkId, NocLinkShift>& list_of_noc_link_shift_directions) {
+void draw_noc_links(ezgl::renderer* g,
+                    t_logical_block_type_ptr noc_router_logical_block_type,
+                    vtr::vector<NocLinkId, ezgl::color>& noc_link_colors,
+                    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();
 
diff --git a/vpr/src/draw/draw_noc.h b/vpr/src/draw/draw_noc.h
@@ -61,7 +61,12 @@ enum NocLinkType {
 };
 
 /*
- * Since the noc links run in both directions between any two routers, we want to draw them parallel to each other instead of ovrelapping them. So the idea is to shift one link in one direction and shift the other link in the opposite direction. THe enum below defines the direction a link was shifted, so for example if we had a vertical line, top would be mean shift left and Bottom would mean shift right. SImilarily, if we had a horizontal line, top would mean shift up and bottom would mean shift down.
+ * Since the noc links run in both directions between any two routers,
+ * we want to draw them parallel to each other instead of overlapping them.
+ * So the idea is to shift one link in one direction and shift the other link
+ * in the opposite direction. The enum below defines the direction a link was shifted,
+ * so for example if we had a vertical line, top would be mean shift left and Bottom would mean shift right.
+ * Similarly, if we had a horizontal line, top would mean shift up and bottom would mean shift down.
  */
 enum NocLinkShift {
     NO_SHIFT, // initially there is no shift
@@ -173,7 +178,11 @@ void draw_noc_connection_marker(ezgl::renderer* g, const vtr::vector<NocRouterId
  * will overlap. This vector describes how the two links should be moved
  * so that they do not overlap.
  */
-void draw_noc_links(ezgl::renderer* g, t_logical_block_type_ptr noc_router_logical_block_type, vtr::vector<NocLinkId, ezgl::color>& noc_link_colors, ezgl::rectangle noc_connection_marker_bbox, const vtr::vector<NocLinkId, NocLinkShift>& list_of_noc_link_shift_directions);
+void draw_noc_links(ezgl::renderer* g,
+                    t_logical_block_type_ptr noc_router_logical_block_type,
+                    vtr::vector<NocLinkId, ezgl::color>& noc_link_colors,
+                    ezgl::rectangle noc_connection_marker_bbox,
+                    const vtr::vector<NocLinkId, NocLinkShift>& list_of_noc_link_shift_directions);
 
 /**
  * @brief Goes through all the links within the NoC and updates the color that
