Merge pull request #2389 from verilog-to-routing/placement_debug_tool

Placement Debug Messages

Author: vaughnbetz

doc/src/vpr/command_line_usage.rst

@@ -879,6 +879,38 @@ Setting any of the following options selects `Dusty's annealing schedule <dusty_
 
     **Default:** ``move_block_type``
 
+.. option:: --placer_debug_block <int>
+    
+    .. note:: This option is likely only of interest to developers debugging the placement algorithm
+
+    Controls which block the placer produces detailed debug information for. 
+    
+    If the block being moved has the same ID as the number assigned to this parameter, the placer will print debugging information about it.
+
+    * For values >= 0, the value is the block ID for which detailed placer debug information should be produced.
+    * For value == -1, detailed placer debug information is produced for all blocks.
+    * For values < -1, no placer debug output is produced.
+
+    .. warning:: VPR must have been compiled with `VTR_ENABLE_DEBUG_LOGGING` on to get any debug output from this option.
+
+    **Default:** ``-2``
+
+.. option:: --placer_debug_net <int>
+    
+    .. note:: This option is likely only of interest to developers debugging the placement algorithm
+
+    Controls which net the placer produces detailed debug information for.
+
+    If a net with the same ID assigned to this parameter is connected to the block that is being moved, the placer will print debugging information about it.
+
+    * For values >= 0, the value is the net ID for which detailed placer debug information should be produced.
+    * For value == -1, detailed placer debug information is produced for all nets.
+    * For values < -1, no placer debug output is produced.
+
+    .. warning:: VPR must have been compiled with `VTR_ENABLE_DEBUG_LOGGING` on to get any debug output from this option.
+
+    **Default:** ``-2``
+
 
 .. _timing_driven_placer_options:
 

vpr/src/base/SetupVPR.cpp

@@ -677,6 +677,9 @@ static void SetupPlacerOpts(const t_options& Options, t_placer_opts* PlacerOpts)
     PlacerOpts->floorplan_num_vertical_partitions = Options.floorplan_num_vertical_partitions;
 
     PlacerOpts->seed = Options.Seed;
+
+    PlacerOpts->placer_debug_block = Options.placer_debug_block;
+    PlacerOpts->placer_debug_net = Options.placer_debug_net;
 }
 
 static void SetupAnalysisOpts(const t_options& Options, t_analysis_opts& analysis_opts) {

vpr/src/base/read_options.cpp

@@ -2122,6 +2122,30 @@ argparse::ArgumentParser create_arg_parser(std::string prog_name, t_options& arg
         .choices({"move_type", "move_block_type"})
         .show_in(argparse::ShowIn::HELP_ONLY);
 
+    place_grp.add_argument(args.placer_debug_block, "--placer_debug_block")
+        .help(
+            " Controls when placer debugging is enabled for blocks.\n"
+            " * For values >= 0, the value is taken as the block ID for\n"
+            "   which to enable placer debug output.\n"
+            " * For value == -1, placer debug output is enabled for\n"
+            "   all blocks.\n"
+            " * For values < -1, all block-based placer debug output is disabled.\n"
+            "Note if VPR as compiled without debug logging enabled this will produce only limited output.\n")
+        .default_value("-2")
+        .show_in(argparse::ShowIn::HELP_ONLY);
+
+    place_grp.add_argument(args.placer_debug_net, "--placer_debug_net")
+        .help(
+            "Controls when placer debugging is enabled for nets.\n"
+            " * For values >= 0, the value is taken as the net ID for\n"
+            "   which to enable placer debug output.\n"
+            " * For value == -1, placer debug output is enabled for\n"
+            "   all nets.\n"
+            " * For values < -1, all net-based placer debug output is disabled.\n"
+            "Note if VPR as compiled without debug logging enabled this will produce only limited output.\n")
+        .default_value("-2")
+        .show_in(argparse::ShowIn::HELP_ONLY);
+
     auto& place_timing_grp = parser.add_argument_group("timing-driven placement options");
 
     place_timing_grp.add_argument(args.PlaceTimingTradeoff, "--timing_tradeoff")

vpr/src/base/read_options.h

@@ -143,6 +143,9 @@ struct t_options {
     argparse::ArgValue<int> floorplan_num_horizontal_partitions;
     argparse::ArgValue<int> floorplan_num_vertical_partitions;
 
+    argparse::ArgValue<int> placer_debug_block;
+    argparse::ArgValue<int> placer_debug_net;
+
     /*NoC Options*/
     argparse::ArgValue<bool> noc;
     argparse::ArgValue<std::string> noc_flows_file;

vpr/src/base/vpr_context.h

@@ -396,6 +396,12 @@ struct PlacementContext : public Context {
      * Used for unique identification and consistency checking
      */
     std::string placement_id;
+
+    /**
+     * Use during placement to print extra debug information. It is set to true based on the number assigned to
+     * placer_debug_net or placer_debug_block parameters in the command line.
+     */
+    bool f_placer_debug = false;
 };
 
 /**

vpr/src/base/vpr_types.h

@@ -1199,6 +1199,9 @@ struct t_placer_opts {
     int floorplan_num_horizontal_partitions;
     int floorplan_num_vertical_partitions;
 
+    int placer_debug_block;
+    int placer_debug_net;
+
     /**
      * @brief Tile types that should be used during delay sampling.
      *

vpr/src/place/centroid_move_generator.cpp

@@ -7,7 +7,12 @@
 
 e_create_move CentroidMoveGenerator::propose_move(t_pl_blocks_to_be_moved& blocks_affected, t_propose_action& proposed_action, float rlim, const t_placer_opts& placer_opts, const PlacerCriticalities* /*criticalities*/) {
     //Find a movable block based on blk_type
-    ClusterBlockId b_from = propose_block_to_move(proposed_action.logical_blk_type_index, false, nullptr, nullptr);
+    ClusterBlockId b_from = propose_block_to_move(placer_opts,
+                                                  proposed_action.logical_blk_type_index,
+                                                  false,
+                                                  nullptr,
+                                                  nullptr);
+    VTR_LOGV_DEBUG(g_vpr_ctx.placement().f_placer_debug, "Centroid Move Choose Block %d - rlim %f\n", size_t(b_from), rlim);
 
     if (!b_from) { //No movable block found
         return e_create_move::ABORT;

vpr/src/place/critical_uniform_move_generator.cpp

@@ -3,11 +3,16 @@
 #include "place_constraints.h"
 #include "move_utils.h"
 
-e_create_move CriticalUniformMoveGenerator::propose_move(t_pl_blocks_to_be_moved& blocks_affected, t_propose_action& proposed_action, float rlim, const t_placer_opts& /*placer_opts*/, const PlacerCriticalities* /*criticalities*/) {
+e_create_move CriticalUniformMoveGenerator::propose_move(t_pl_blocks_to_be_moved& blocks_affected, t_propose_action& proposed_action, float rlim, const t_placer_opts& placer_opts, const PlacerCriticalities* /*criticalities*/) {
     ClusterNetId net_from;
     int pin_from;
     //Find a movable block based on blk_type
-    ClusterBlockId b_from = propose_block_to_move(proposed_action.logical_blk_type_index, true, &net_from, &pin_from);
+    ClusterBlockId b_from = propose_block_to_move(placer_opts,
+                                                  proposed_action.logical_blk_type_index,
+                                                  true,
+                                                  &net_from,
+                                                  &pin_from);
+    VTR_LOGV_DEBUG(g_vpr_ctx.placement().f_placer_debug, "Critical Uniform Move Choose Block %d - rlim %f\n", size_t(b_from), rlim);
 
     auto& place_ctx = g_vpr_ctx.placement();
     auto& cluster_ctx = g_vpr_ctx.clustering();

vpr/src/place/feasible_region_move_generator.cpp

@@ -9,7 +9,12 @@ e_create_move FeasibleRegionMoveGenerator::propose_move(t_pl_blocks_to_be_moved&
     ClusterNetId net_from;
     int pin_from;
     //Find a movable block based on blk_type
-    ClusterBlockId b_from = propose_block_to_move(proposed_action.logical_blk_type_index, true, &net_from, &pin_from);
+    ClusterBlockId b_from = propose_block_to_move(placer_opts,
+                                                  proposed_action.logical_blk_type_index,
+                                                  true,
+                                                  &net_from,
+                                                  &pin_from);
+    VTR_LOGV_DEBUG(g_vpr_ctx.placement().f_placer_debug, "Feasible Region Move Choose Block %di - rlim %f\n", size_t(b_from), rlim);
 
     if (!b_from) { //No movable block found
         return e_create_move::ABORT;

vpr/src/place/initial_placement.cpp

@@ -229,7 +229,7 @@ static bool try_dense_placement(t_pl_macro pl_macro, PartitionRegion& pr, t_logi
  *   @param pad_loc_type Used to check whether an io block needs to be marked as fixed.
  *   @param constraints_file Used to read block locations if any constraints is available.
  */
-static void place_all_blocks(vtr::vector<ClusterBlockId, t_block_score>& block_scores, enum e_pad_loc_type pad_loc_type, const char* constraints_file);
+static void place_all_blocks(const t_placer_opts& placer_opts, vtr::vector<ClusterBlockId, t_block_score>& block_scores, enum e_pad_loc_type pad_loc_type, const char* constraints_file);
 
 /**
  * @brief If any blocks remain unplaced after all initial placement iterations, this routine
@@ -780,6 +780,12 @@ static bool try_dense_placement(t_pl_macro pl_macro, PartitionRegion& pr, t_logi
 static bool try_place_macro(t_pl_macro pl_macro, t_pl_loc head_pos) {
     auto& place_ctx = g_vpr_ctx.mutable_placement();
 
+    VTR_LOGV_DEBUG(place_ctx.f_placer_debug, "\t\t\t\tTry to place the macro at %dx%dx%dx%d\n",
+                   head_pos.x,
+                   head_pos.y,
+                   head_pos.sub_tile,
+                   head_pos.layer);
+
     bool macro_placed = false;
 
     // If that location is occupied, do nothing.
@@ -792,6 +798,7 @@ static bool try_place_macro(t_pl_macro pl_macro, t_pl_loc head_pos) {
     if (mac_can_be_placed) {
         // Place down the macro
         macro_placed = true;
+        VTR_LOGV_DEBUG(place_ctx.f_placer_debug, "\t\t\t\tMacro is placed at the given location\n");
         for (size_t imember = 0; imember < pl_macro.members.size(); imember++) {
             t_pl_loc member_pos = head_pos + pl_macro.members[imember].offset;
 
@@ -808,8 +815,10 @@ static bool try_place_macro(t_pl_macro pl_macro, t_pl_loc head_pos) {
 static bool place_macro(int macros_max_num_tries, t_pl_macro pl_macro, enum e_pad_loc_type pad_loc_type, std::vector<t_grid_empty_locs_block_type>* blk_types_empty_locs_in_grid, vtr::vector<ClusterBlockId, t_block_score>& block_scores) {
     ClusterBlockId blk_id;
     blk_id = pl_macro.members[0].blk_index;
+    VTR_LOGV_DEBUG(g_vpr_ctx.placement().f_placer_debug, "\t\tHead of the macro is Block %d\n", size_t(blk_id));
 
     if (is_block_placed(blk_id)) {
+        VTR_LOGV_DEBUG(g_vpr_ctx.placement().f_placer_debug, "\t\t\tBlock is already placed\n", size_t(blk_id));
         return true;
     }
 
@@ -826,6 +835,7 @@ static bool place_macro(int macros_max_num_tries, t_pl_macro pl_macro, enum e_pa
     //Enough to check head member of macro to see if its constrained because
     //constraints propagation was done earlier in initial placement.
     if (is_cluster_constrained(blk_id)) {
+        VTR_LOGV_DEBUG(g_vpr_ctx.placement().f_placer_debug, "\t\t\tMacro's head is constrained\n");
         pr = floorplanning_ctx.cluster_constraints[blk_id];
     } else { //If the block is not constrained, assign a region the size of the grid to its PartitionRegion
         Region reg;
@@ -843,15 +853,18 @@ static bool place_macro(int macros_max_num_tries, t_pl_macro pl_macro, enum e_pa
     //If blk_types_empty_locs_in_grid is not NULL, means that initial placement has been failed in first iteration for this block type
     //We need to place densely in second iteration to be able to find a legal initial placement solution
     if (blk_types_empty_locs_in_grid != NULL && blk_types_empty_locs_in_grid->size() != 0) {
+        VTR_LOGV_DEBUG(g_vpr_ctx.placement().f_placer_debug, "\t\t\tTry dense placement\n");
         macro_placed = try_dense_placement(pl_macro, pr, block_type, pad_loc_type, blk_types_empty_locs_in_grid);
     }
 
     if (!macro_placed) {
+        VTR_LOGV_DEBUG(g_vpr_ctx.placement().f_placer_debug, "\t\t\tTry centroid placement\n");
         macro_placed = try_centroid_placement(pl_macro, pr, block_type, pad_loc_type, block_scores);
     }
-
+    VTR_LOGV_DEBUG(g_vpr_ctx.placement().f_placer_debug, "\t\t\tMacro is placed: %d\n", macro_placed);
     // If macro is not placed yet, try to place the macro randomly for the max number of random tries
     for (int itry = 0; itry < macros_max_num_tries && macro_placed == false; itry++) {
+        VTR_LOGV_DEBUG(g_vpr_ctx.placement().f_placer_debug, "\t\t\tTry random place iter: %d\n", itry);
         macro_placed = try_random_placement(pl_macro, pr, block_type, pad_loc_type);
     } // Finished all tries
 
@@ -863,6 +876,7 @@ static bool place_macro(int macros_max_num_tries, t_pl_macro pl_macro, enum e_pa
         // if there are no legal positions, error out
 
         // Exhaustive placement of carry macros
+        VTR_LOGV_DEBUG(g_vpr_ctx.placement().f_placer_debug, "\t\t\tTry exhaustive placement\n");
         macro_placed = try_exhaustive_placement(pl_macro, pr, block_type, pad_loc_type);
     }
     return macro_placed;
@@ -913,7 +927,11 @@ static vtr::vector<ClusterBlockId, t_block_score> assign_block_scores() {
     return block_scores;
 }
 
-static void place_all_blocks(vtr::vector<ClusterBlockId, t_block_score>& block_scores, enum e_pad_loc_type pad_loc_type, const char* constraints_file) {
+#ifdef VTR_ENABLE_DEBUG_LOGGING
+static void place_all_blocks(const t_placer_opts& placer_opts, vtr::vector<ClusterBlockId, t_block_score>& block_scores, enum e_pad_loc_type pad_loc_type, const char* constraints_file) {
+#else
+static void place_all_blocks(const t_placer_opts& /* placer_opts */, vtr::vector<ClusterBlockId, t_block_score>& block_scores, enum e_pad_loc_type pad_loc_type, const char* constraints_file) {
+#endif
     auto& cluster_ctx = g_vpr_ctx.clustering();
     auto& place_ctx = g_vpr_ctx.placement();
     auto& device_ctx = g_vpr_ctx.device();
@@ -963,6 +981,12 @@ static void place_all_blocks(vtr::vector<ClusterBlockId, t_block_score>& block_s
             heap_blocks.pop_back();
 
             auto blk_id_type = cluster_ctx.clb_nlist.block_type(blk_id);
+
+#ifdef VTR_ENABLE_DEBUG_LOGGING
+            enable_placer_debug(placer_opts, blk_id);
+#endif
+            VTR_LOGV_DEBUG(g_vpr_ctx.placement().f_placer_debug, "Popped Block %d\n", size_t(blk_id));
+
             blocks_placed_since_heap_update++;
 
             bool block_placed = place_one_block(blk_id, pad_loc_type, &blk_types_empty_locs_in_grid[blk_id_type->index], &block_scores);
@@ -974,6 +998,7 @@ static void place_all_blocks(vtr::vector<ClusterBlockId, t_block_score>& block_s
             }
 
             if (!block_placed) {
+                VTR_LOGV_DEBUG(g_vpr_ctx.placement().f_placer_debug, "Didn't find a location the block\n", size_t(blk_id));
                 //add current block to list to ensure it will be placed sooner in the next iteration in initial placement
                 number_of_unplaced_blks_in_curr_itr++;
                 block_scores[blk_id].failed_to_place_in_prev_attempts++;
@@ -1065,6 +1090,7 @@ bool place_one_block(const ClusterBlockId& blk_id,
     get_imacro_from_iblk(&imacro, blk_id, place_ctx.pl_macros);
 
     if (imacro != -1) { //If the block belongs to a macro, pass that macro to the placement routines
+        VTR_LOGV_DEBUG(g_vpr_ctx.placement().f_placer_debug, "\tBelongs to a macro %d\n", imacro);
         pl_macro = place_ctx.pl_macros[imacro];
         placed_macro = place_macro(MAX_NUM_TRIES_TO_PLACE_MACROS_RANDOMLY, pl_macro, pad_loc_type, blk_types_empty_locs_in_grid, (*block_scores));
     } else {
@@ -1082,7 +1108,10 @@ bool place_one_block(const ClusterBlockId& blk_id,
     return placed_macro;
 }
 
-void initial_placement(enum e_pad_loc_type pad_loc_type, const char* constraints_file, bool noc_enabled) {
+void initial_placement(const t_placer_opts& placer_opts,
+                       enum e_pad_loc_type pad_loc_type,
+                       const char* constraints_file,
+                       bool noc_enabled) {
     vtr::ScopedStartFinishTimer timer("Initial Placement");
 
     /* Go through cluster blocks to calculate the tightest placement
@@ -1098,7 +1127,7 @@ void initial_placement(enum e_pad_loc_type pad_loc_type, const char* constraints
     vtr::vector<ClusterBlockId, t_block_score> block_scores = assign_block_scores();
 
     //Place all blocks
-    place_all_blocks(block_scores, pad_loc_type, constraints_file);
+    place_all_blocks(placer_opts, block_scores, pad_loc_type, constraints_file);
 
     //if any blocks remain unplaced, print an error
     check_initial_placement_legality();