[vpr][place] moved_block uses size() to indicate valid elements

Author: Yulang Luo

vpr/src/place/move_transactions.cpp

@@ -1,8 +1,20 @@
 #include "move_utils.h"
 
 #include "globals.h"
+// Is this needed?
 #include "place_util.h"
 
+t_pl_blocks_to_be_moved::t_pl_blocks_to_be_moved(size_t max_blocks){
+        moved_blocks.reserve(max_blocks);
+        moved_blocks.resize(0);
+}
+
+size_t t_pl_blocks_to_be_moved::get_size_and_increment() {
+    VTR_ASSERT(moved_blocks.size() < moved_blocks.capacity());
+    moved_blocks.resize(moved_blocks.size() + 1);
+    return moved_blocks.size() - 1;
+}
+
 //Records that block 'blk' should be moved to the specified 'to' location
 e_block_move_result record_block_move(t_pl_blocks_to_be_moved& blocks_affected, ClusterBlockId blk, t_pl_loc to) {
     auto res = blocks_affected.moved_to.emplace(to);
@@ -24,11 +36,10 @@ e_block_move_result record_block_move(t_pl_blocks_to_be_moved& blocks_affected,
     VTR_ASSERT_SAFE(to.sub_tile < int(place_ctx.grid_blocks.num_blocks_at_location({to.x, to.y, to.layer})));
 
     // Sets up the blocks moved
-    int imoved_blk = blocks_affected.num_moved_blocks;
+    size_t imoved_blk = blocks_affected.get_size_and_increment();
     blocks_affected.moved_blocks[imoved_blk].block_num = blk;
     blocks_affected.moved_blocks[imoved_blk].old_loc = from;
     blocks_affected.moved_blocks[imoved_blk].new_loc = to;
-    blocks_affected.num_moved_blocks++;
 
     return e_block_move_result::VALID;
 }
@@ -40,7 +51,7 @@ void apply_move_blocks(const t_pl_blocks_to_be_moved& blocks_affected) {
 
     //Swap the blocks, but don't swap the nets or update place_ctx.grid_blocks
     //yet since we don't know whether the swap will be accepted
-    for (int iblk = 0; iblk < blocks_affected.num_moved_blocks; ++iblk) {
+    for (size_t iblk = 0; iblk < blocks_affected.moved_blocks.size(); ++iblk) {
         ClusterBlockId blk = blocks_affected.moved_blocks[iblk].block_num;
 
         const t_pl_loc& old_loc = blocks_affected.moved_blocks[iblk].old_loc;
@@ -67,7 +78,7 @@ void commit_move_blocks(const t_pl_blocks_to_be_moved& blocks_affected) {
     auto& place_ctx = g_vpr_ctx.mutable_placement();
 
     /* Swap physical location */
-    for (int iblk = 0; iblk < blocks_affected.num_moved_blocks; ++iblk) {
+    for (size_t iblk = 0; iblk < blocks_affected.moved_blocks.size(); ++iblk) {
         ClusterBlockId blk = blocks_affected.moved_blocks[iblk].block_num;
 
         const t_pl_loc& to = blocks_affected.moved_blocks[iblk].new_loc;
@@ -97,7 +108,7 @@ void revert_move_blocks(const t_pl_blocks_to_be_moved& blocks_affected) {
     auto& device_ctx = g_vpr_ctx.device();
 
     // Swap the blocks back, nets not yet swapped they don't need to be changed
-    for (int iblk = 0; iblk < blocks_affected.num_moved_blocks; ++iblk) {
+    for (size_t iblk = 0; iblk < blocks_affected.moved_blocks.size(); ++iblk) {
         ClusterBlockId blk = blocks_affected.moved_blocks[iblk].block_num;
 
         const t_pl_loc& old_loc = blocks_affected.moved_blocks[iblk].old_loc;
@@ -126,10 +137,10 @@ void clear_move_blocks(t_pl_blocks_to_be_moved& blocks_affected) {
     blocks_affected.moved_to.clear();
     blocks_affected.moved_from.clear();
 
-    //For run-time, we just reset num_moved_blocks to zero, but do not free the blocks_affected
+    //For run-time, we just reset size of blocks_affected.moved_blocks to zero, but do not free the blocks_affected
     //array to avoid memory allocation
 
-    blocks_affected.num_moved_blocks = 0;
+    blocks_affected.moved_blocks.resize(0);
 
     blocks_affected.affected_pins.clear();
 }

vpr/src/place/move_transactions.h

@@ -25,24 +25,21 @@ struct t_pl_moved_block {
  * placement, in the form of array of structs instead of struct with    *
  * arrays for cache effifiency                                          *
  *
- * num_moved_blocks: total number of blocks moved when          *
- *                   swapping two blocks.                       *
  * moved blocks: a list of moved blocks data structure with     *
  *               information on the move.                       *
  *               [0...max_blocks-1]                       *
  * affected_pins: pins affected by this move (used to           *
  *                incrementally invalidate parts of the timing  *
  *                graph.                                        */
 struct t_pl_blocks_to_be_moved {
-    explicit t_pl_blocks_to_be_moved(size_t max_blocks)
-        : moved_blocks(max_blocks) {}
+    explicit t_pl_blocks_to_be_moved(size_t max_blocks);
 
-    int num_moved_blocks = 0;
     std::vector<t_pl_moved_block> moved_blocks;
     std::unordered_set<t_pl_loc> moved_from;
     std::unordered_set<t_pl_loc> moved_to;
 
     std::vector<ClusterPinId> affected_pins;
+    size_t get_size_and_increment();
 };
 
 enum class e_block_move_result {

vpr/src/place/move_utils.cpp

@@ -488,7 +488,7 @@ std::set<t_pl_loc> determine_locations_emptied_by_move(t_pl_blocks_to_be_moved&
     std::set<t_pl_loc> moved_from;
     std::set<t_pl_loc> moved_to;
 
-    for (int iblk = 0; iblk < blocks_affected.num_moved_blocks; ++iblk) {
+    for (size_t iblk = 0; iblk < blocks_affected.moved_blocks.size(); ++iblk) {
         //When a block is moved its old location becomes free
         moved_from.emplace(blocks_affected.moved_blocks[iblk].old_loc);
 

vpr/src/place/net_cost_handler.cpp

@@ -156,7 +156,6 @@ static BBUpdater bb_updater;
  * @return True if the driver block of the net is among the moving blocks
  */
 static bool driven_by_moved_block(const ClusterNetId net,
-                                  const int num_blocks,
                                   const std::vector<t_pl_moved_block>& moved_blocks);
 /**
  * @brief Update the bounding box (3D) of the net connected to blk_pin. The old and new locations of the pin are
@@ -555,14 +554,13 @@ void BBUpdater::set_ts_edge(const ClusterNetId& net_id) {
 
 //Returns true if 'net' is driven by one of the blocks in 'blocks_affected'
 static bool driven_by_moved_block(const ClusterNetId net,
-                                  const int num_blocks,
                                   const std::vector<t_pl_moved_block>& moved_blocks) {
     auto& clb_nlist = g_vpr_ctx.clustering().clb_nlist;
     bool is_driven_by_move_blk = false;
     ClusterBlockId net_driver_block = clb_nlist.net_driver_block(
         net);
 
-    for (int block_num = 0; block_num < num_blocks; block_num++) {
+    for (size_t block_num = 0; block_num < moved_blocks.size(); block_num++) {
         if (net_driver_block == moved_blocks[block_num].block_num) {
             is_driven_by_move_blk = true;
             break;
@@ -1918,7 +1916,7 @@ void find_affected_nets_and_update_costs(
     ts_info.ts_nets_to_update.resize(0);
 
     /* Go through all the blocks moved. */
-    for (int iblk = 0; iblk < blocks_affected.num_moved_blocks; iblk++) {
+    for (size_t iblk = 0; iblk < blocks_affected.moved_blocks.size(); iblk++) {
         const auto& moving_block_inf = blocks_affected.moved_blocks[iblk];
         auto& affected_pins = blocks_affected.affected_pins;
         ClusterBlockId blk = blocks_affected.moved_blocks[iblk].block_num;
@@ -1929,7 +1927,6 @@ void find_affected_nets_and_update_costs(
             if (clb_nlist.pin_type(blk_pin) == PinType::SINK) {
                 ClusterNetId net_id = clb_nlist.pin_net(blk_pin);
                 is_src_moving = driven_by_moved_block(net_id,
-                                                      blocks_affected.num_moved_blocks,
                                                       blocks_affected.moved_blocks);
             }
             update_net_info_on_pin_move(place_algorithm,

vpr/src/place/noc_place_utils.cpp

@@ -136,7 +136,7 @@ void find_affected_noc_routers_and_update_noc_costs(const t_pl_blocks_to_be_move
     affected_noc_links.clear();
 
     // go through the moved blocks and process them only if they are NoC routers
-    for (int iblk = 0; iblk < blocks_affected.num_moved_blocks; ++iblk) {
+    for (size_t iblk = 0; iblk < blocks_affected.moved_blocks.size(); ++iblk) {
         ClusterBlockId blk = blocks_affected.moved_blocks[iblk].block_num;
 
         // check if the current moved block is a noc router
@@ -291,7 +291,7 @@ void revert_noc_traffic_flow_routes(const t_pl_blocks_to_be_moved& blocks_affect
     std::unordered_set<NocTrafficFlowId> reverted_traffic_flows;
 
     // go through the moved blocks and process them only if they are NoC routers
-    for (int iblk = 0; iblk < blocks_affected.num_moved_blocks; ++iblk) {
+    for (size_t iblk = 0; iblk < blocks_affected.moved_blocks.size(); ++iblk) {
         ClusterBlockId blk = blocks_affected.moved_blocks[iblk].block_num;
 
         // check if the current moved block is a noc router

vpr/src/place/place.cpp

@@ -150,7 +150,7 @@ std::unique_ptr<FILE, decltype(&vtr::fclose)> f_move_stats_file(nullptr,
                         t,                                                                     \
                         int(b_from), int(b_to),                                                \
                         from_type->name, (to_type ? to_type->name : "EMPTY"),                  \
-                        affected_blocks.num_moved_blocks);                                     \
+                        affected_blocks.moved_blocks.size());                                     \
             }                                                                                  \
         } while (false)
 

vpr/src/place/place_constraints.h

@@ -100,7 +100,7 @@ void print_macro_constraint_error(const t_pl_macro& pl_macro);
 inline bool floorplan_legal(const t_pl_blocks_to_be_moved& blocks_affected) {
     bool floorplan_legal;
 
-    for (int i = 0; i < blocks_affected.num_moved_blocks; i++) {
+    for (size_t i = 0; i < blocks_affected.moved_blocks.size(); i++) {
         floorplan_legal = cluster_floorplanning_legal(blocks_affected.moved_blocks[i].block_num,
                                                       blocks_affected.moved_blocks[i].new_loc);
         if (!floorplan_legal) {

vpr/test/test_noc_place_utils.cpp

@@ -748,7 +748,7 @@ TEST_CASE("test_find_affected_noc_routers_and_update_noc_costs, test_commit_noc_
         } while (swap_router_block_one == swap_router_block_two);
 
         //set up the moved blocks datastructure for the test function
-        blocks_affected.num_moved_blocks = 2;
+        blocks_affected.moved_blocks.resize(2);
 
         blocks_affected.moved_blocks[0].block_num = swap_router_block_one;
         blocks_affected.moved_blocks[0].old_loc = t_pl_loc(noc_ctx.noc_model.get_single_noc_router(router_where_cluster_is_placed[swap_router_block_one]).get_router_grid_position_x(),
@@ -903,7 +903,7 @@ TEST_CASE("test_find_affected_noc_routers_and_update_noc_costs, test_commit_noc_
 
     // now perform the swap
     //set up the moved blocks datastructure for the test function
-    blocks_affected.num_moved_blocks = 2;
+    blocks_affected.moved_blocks.resize(2);
 
     blocks_affected.moved_blocks[0].block_num = swap_router_block_one;
 
@@ -1039,7 +1039,7 @@ TEST_CASE("test_find_affected_noc_routers_and_update_noc_costs, test_commit_noc_
 
     // now perform the swap
     //set up the moved blocks datastructure for the test function
-    blocks_affected.num_moved_blocks = 2;
+    blocks_affected.moved_blocks.resize(2);
 
     blocks_affected.moved_blocks[0].block_num = swap_router_block_one;
 
@@ -1142,7 +1142,7 @@ TEST_CASE("test_find_affected_noc_routers_and_update_noc_costs, test_commit_noc_
 
     // now perform the swap
     //set up the moved blocks datastructure for the test function
-    blocks_affected.num_moved_blocks = 2;
+    blocks_affected.moved_blocks.resize(2);
 
     blocks_affected.moved_blocks[0].block_num = swap_router_block_one;
 
@@ -1584,7 +1584,7 @@ TEST_CASE("test_revert_noc_traffic_flow_routes", "[noc_place_utils]") {
 
     //set up the moved blocks datastructure for the test function
     // this is needed for the test function (it needs to know what blocks were swapped, so it can undo it)
-    blocks_affected.num_moved_blocks = 2;
+    blocks_affected.moved_blocks.resize(2);
 
     blocks_affected.moved_blocks[0].block_num = swap_router_block_one;
     blocks_affected.moved_blocks[0].old_loc = t_pl_loc(noc_ctx.noc_model.get_single_noc_router(router_where_cluster_is_placed[swap_router_block_one]).get_router_grid_position_x(),