added some comments

Author: soheilshahrouz

vpr/src/place/RL_agent_util.h

@@ -14,7 +14,6 @@ enum class e_agent_state {
  *
  * This function creates 2 move generators to be used by the annealer. The type of the move generators created here depends on the 
  * type selected in placer_opts.
- * It returns a unique pointer for each move generator in move_generator and move_generator2
  *
  * @param placer_state Move generators store a reference to the placer context to avoid global state access.
  * @param placer_opts Contains information about the placement algorithm and its parameters.

vpr/src/place/analytic_placer.cpp

@@ -303,11 +303,11 @@ void AnalyticPlacer::build_legal_locations() {
 // initialize other data members
 void AnalyticPlacer::init() {
     const ClusteredNetlist& clb_nlist = g_vpr_ctx.clustering().clb_nlist;
-    auto& block_locs = blk_loc_registry_ref_.block_locs();
+    auto& init_block_locs = blk_loc_registry_ref_.block_locs();
 
     for (auto blk_id : clb_nlist.blocks()) {
         blk_locs.insert(blk_id, BlockLocation{});
-        blk_locs[blk_id].loc = block_locs[blk_id].loc; // transfer of initial placement
+        blk_locs[blk_id].loc = init_block_locs[blk_id].loc; // transfer of initial placement
         row_num.insert(blk_id, DONT_SOLVE);                      // no blocks are moved by default, until they are setup in setup_solve_blks()
     }
 
@@ -322,7 +322,7 @@ void AnalyticPlacer::init() {
     };
 
     for (auto blk_id : clb_nlist.blocks()) {
-        if (!block_locs[blk_id].is_fixed && has_connections(blk_id))
+        if (!init_block_locs[blk_id].is_fixed && has_connections(blk_id))
             // not fixed and has connections
             // matrix equation is formulated based on connections, so requires at least one connection
             if (imacro(blk_id) == NO_MACRO || macro_head(blk_id) == blk_id) {

vpr/src/place/centroid_move_generator.h

@@ -21,8 +21,11 @@
 class CentroidMoveGenerator : public MoveGenerator {
   public:
     /**
-     * The move generator created by calling this constructor only consider
+     * The move generator created by calling this constructor only considers
      * netlist connectivity for computing the centroid location.
+     *
+     * @param placer_state A mutable reference to the placement state which will
+     * be stored in this object.
      */
     explicit CentroidMoveGenerator(PlacerState& placer_state);
 
@@ -33,6 +36,8 @@ class CentroidMoveGenerator : public MoveGenerator {
      * in the graph representing the clustered netlist. When finding connected
      * components, none of the nets whose fanout is larger than high_fanout_net
      * are traversed.
+     * @param placer_state A mutable reference to the placement state which will
+     * be stored in this object.
      * @param noc_attraction_weight Specifies how much the computed centroid
      * is adjusted towards the location of NoC routers in the same NoC group as
      * the clustered block to be moved.

vpr/src/place/median_move_generator.cpp

@@ -186,16 +186,6 @@ e_create_move MedianMoveGenerator::propose_move(t_pl_blocks_to_be_moved& blocks_
     return create_move;
 }
 
-/* Finds the bounding box of a net and stores its coordinates in the  *
- * bb_coord_new data structure. It excludes the moving block sent in  *
- * function arguments in block_id. It also returns whether this net   *
- * should be excluded from median calculation or not.                 *
- * This routine should only be called for small nets, since it does   *
- * not determine enough information for the bounding box to be        *
- * updated incrementally later.                                       *
- * Currently assumes channels on both sides of the CLBs forming the   *
- * edges of the bounding box can be used.  Essentially, I am assuming *
- * the pins always lie on the outside of the bounding box.            */
 void MedianMoveGenerator::get_bb_from_scratch_excluding_block(ClusterNetId net_id,
                                                               t_bb& bb_coord_new,
                                                               ClusterBlockId block_id,
@@ -294,19 +284,6 @@ void MedianMoveGenerator::get_bb_from_scratch_excluding_block(ClusterNetId net_i
     bb_coord_new.layer_max = std::max(std::min<int>(layer_max, device_ctx.grid.get_num_layers() - 1), 0);
 }
 
-/*
- * Calculates the bounding box of a net by storing its coordinates    *
- * in the bb_coord_new data structure. It uses information from       *
- * PlaceMoveContext to calculate the bb incrementally. This routine   *
- * should only be called for large nets, since it has some overhead   *
- * relative to just doing a brute force bounding box calculation.     *
- * The bounding box coordinate and edge information for inet must be  *
- * valid before this routine is called.                               *
- * Currently assumes channels on both sides of the CLBs forming the   *
- * edges of the bounding box can be used. Essentially, I am assuming *
- * the pins always lie on the outside of the bounding box.            *
- * The x and y coordinates are the pin's x and y coordinates.         */
-/* IO blocks are considered to be one cell in for simplicity.         */
 bool MedianMoveGenerator::get_bb_incrementally(ClusterNetId net_id,
                                                t_bb& bb_coord_new,
                                                int xold,

vpr/src/place/median_move_generator.h

@@ -27,10 +27,33 @@ class MedianMoveGenerator : public MoveGenerator {
                                const t_placer_opts& placer_opts,
                                const PlacerCriticalities* /*criticalities*/) override;
 
+    /**
+     * @brief Calculates the bounding box of a net by storing its coordinates
+     * in the bb_coord_new data structure.
+     *
+     * @details It uses information from PlaceMoveContext to calculate the bb incrementally.
+     * This routine should only be called for large nets, since it has some overhead
+     * relative to just doing a brute force bounding box calculation. The bounding box coordinate
+     * and edge information for inet must be valid before this routine is called.
+     * Currently assumes channels on both sides of the CLBs forming the edges of the bounding box
+     * can be used. Essentially, I am assuming the pins always lie on the outside of the bounding box.
+     * The x and y coordinates are the pin's x and y coordinates. IO blocks are considered to be
+     * one cell in for simplicity. */
     bool get_bb_incrementally(ClusterNetId net_id, t_bb& bb_coord_new,
                               int xold, int yold, int layer_old,
                               int xnew, int ynew, int layer_new);
 
+
+    /**
+     * @brief Finds the bounding box of a net and stores its coordinates in the bb_coord_new data structure.
+     *
+     * @details It excludes the moving block sent in function arguments in block_id.
+     * It also returns whether this net should be excluded from median calculation or not.
+     * This routine should only be called for small nets, since it does not determine
+     * enough information for the bounding box to be updated incrementally later.
+     * Currently assumes channels on both sides of the CLBs forming the edges of the bounding box can be used.
+     * Essentially, I am assuming the pins always lie on the outside of the bounding box.
+     */
     void get_bb_from_scratch_excluding_block(ClusterNetId net_id,
                                              t_bb& bb_coord_new,
                                              ClusterBlockId block_id,