replace unordered_map with vector for storing movable blocks for each type

Author: soheilshahrouz

vpr/src/base/vpr_context.h

@@ -390,7 +390,7 @@ struct PlacementContext : public Context {
     std::vector<ClusterBlockId> movable_blocks;
 
     ///@brief Stores ClusterBlockId of all movable clustered of each block type
-    std::unordered_map<int, std::vector<ClusterBlockId>> movable_blocks_per_type;
+    std::vector<std::vector<ClusterBlockId>> movable_blocks_per_type;
 
     /**
      * @brief Compressed grid space for each block type

vpr/src/place/initial_placement.cpp

@@ -230,6 +230,7 @@ static void alloc_and_load_movable_blocks();
 static void check_initial_placement_legality() {
     auto& cluster_ctx = g_vpr_ctx.clustering();
     auto& place_ctx = g_vpr_ctx.placement();
+    auto& device_ctx = g_vpr_ctx.device();
 
     int unplaced_blocks = 0;
 
@@ -256,19 +257,19 @@ static void check_initial_placement_legality() {
             VPR_FATAL_ERROR(VPR_ERROR_PLACE, "Fixed block was mistakenly marked as movable during initial placement.\n");
         }
     }
-
-    for (const auto& blk_type : place_ctx.movable_blocks_per_type) {
-        int logical_block_type = blk_type.first;
-        const auto& movable_blocks = blk_type.second;
-        for (auto movable_blk_id : movable_blocks) {
+    
+    for (const auto& logical_block_type : device_ctx.logical_block_types) {
+        const auto& movable_blocks_of_type = place_ctx.movable_blocks_per_type[logical_block_type.index];
+        for (const auto& movable_blk_id : movable_blocks_of_type) {
             if (place_ctx.block_locs[movable_blk_id].is_fixed) {
-                VPR_FATAL_ERROR(VPR_ERROR_PLACE, "Fixed block of logical type %d was mistakenly marked as movable during initial placement.\n",
-                                logical_block_type);
+                VPR_FATAL_ERROR(VPR_ERROR_PLACE, "Fixed block %d of logical type %s was mistakenly marked as movable during initial placement.\n",
+                                (size_t)movable_blk_id, logical_block_type.name);
             }
-            if (cluster_ctx.clb_nlist.block_type(movable_blk_id)->index != logical_block_type) {
-                VPR_FATAL_ERROR(VPR_ERROR_PLACE, "Clustered block of logical type %d was mistakenly marked as logical type %d.\n",
-                                cluster_ctx.clb_nlist.block_type(movable_blk_id)->index,
-                                logical_block_type);
+            if (cluster_ctx.clb_nlist.block_type(movable_blk_id)->index != logical_block_type.index) {
+                VPR_FATAL_ERROR(VPR_ERROR_PLACE, "Clustered block %d of logical type %s was mistakenly marked as logical type %s.\n",
+                                (size_t)movable_blk_id,
+                                cluster_ctx.clb_nlist.block_type(movable_blk_id)->name,
+                                logical_block_type.name);
             }
         }
     }
@@ -1156,11 +1157,15 @@ bool place_one_block(const ClusterBlockId& blk_id,
 
 static void alloc_and_load_movable_blocks() {
     auto& place_ctx = g_vpr_ctx.mutable_placement();
-    auto& cluster_ctx = g_vpr_ctx.clustering();
+    const auto& cluster_ctx = g_vpr_ctx.clustering();
+    const auto& device_ctx = g_vpr_ctx.device();
 
     place_ctx.movable_blocks.clear();
     place_ctx.movable_blocks_per_type.clear();
 
+    size_t n_logical_blocks = device_ctx.logical_block_types.size();
+    place_ctx.movable_blocks_per_type.resize(n_logical_blocks);
+
 
     // iterate over all clustered blocks and store block ids of movable ones
     for (auto blk_id : cluster_ctx.clb_nlist.blocks()) {

vpr/src/place/move_utils.cpp

@@ -221,7 +221,7 @@ e_block_move_result record_macro_swaps(t_pl_blocks_to_be_moved& blocks_affected,
 //to a new position offset from its current position by swap_offset. The new location must be where
 //blk_to is located and blk_to must be part of imacro_to.
 e_block_move_result record_macro_macro_swaps(t_pl_blocks_to_be_moved& blocks_affected, const int imacro_from, int& imember_from, const int imacro_to, ClusterBlockId blk_to, t_pl_offset swap_offset) {
-    //Adds the macro imacro_to to the set of affected block caused by swapping 'blk_to' to it's
+    //Adds the macro imacro_to to the set of affected block caused by swapping 'blk_to' to its
     //new position.
     //
     //This function is only called when both the main swap's from/to blocks are placement macros.
@@ -484,7 +484,7 @@ std::set<t_pl_loc> determine_locations_emptied_by_move(t_pl_blocks_to_be_moved&
     std::set<t_pl_loc> moved_to;
 
     for (int iblk = 0; iblk < blocks_affected.num_moved_blocks; ++iblk) {
-        //When a block is moved it's old location becomes free
+        //When a block is moved its old location becomes free
         moved_from.emplace(blocks_affected.moved_blocks[iblk].old_loc);
 
         //But any block later moved to a position fills it
@@ -591,19 +591,12 @@ ClusterBlockId propose_block_to_move(const t_placer_opts& /* placer_opts */,
 }
 
 const std::vector<ClusterBlockId>& movable_blocks_per_type(const t_logical_block_type& blk_type) {
-    // empty vector is declared static to avoid re-allocation every time the function is called
-    static std::vector<ClusterBlockId> empty_vector;
-
     const auto& place_ctx = g_vpr_ctx.placement();
 
-    if (place_ctx.movable_blocks_per_type.count(blk_type.index) == 0) {
-        return empty_vector;
-    }
-
     // the vector is returned as const reference to avoid unnecessary copies,
     // especially that returned vectors may be very large as they contain
     // all clustered blocks with a specific block type
-    return place_ctx.movable_blocks_per_type.at(blk_type.index);
+    return place_ctx.movable_blocks_per_type[blk_type.index];
 }
 
 //Pick a random movable block to be swapped with another random block.
@@ -629,22 +622,15 @@ ClusterBlockId pick_from_block() {
 ClusterBlockId pick_from_block(const int logical_blk_type_index) {
     auto& place_ctx = g_vpr_ctx.mutable_placement();
 
-    auto found_blocks = place_ctx.movable_blocks_per_type.find(logical_blk_type_index);
-    if (found_blocks != place_ctx.movable_blocks_per_type.end()) {
-        const auto& blocks_per_type = found_blocks->second;
-        //no blocks with this type is movable
-        if (blocks_per_type.empty()) {
-            return ClusterBlockId::INVALID();
-        }
-
-        //Pick a block at random
-        auto b_from = ClusterBlockId(blocks_per_type[vtr::irand((int)blocks_per_type.size() - 1)]);
+    const auto& movable_blocks_of_type = place_ctx.movable_blocks_per_type[logical_blk_type_index];
 
-        // return the movable block of the given type
-        return b_from;
+    if (movable_blocks_of_type.empty()) {
+        return ClusterBlockId::INVALID();
     }
 
-    return ClusterBlockId::INVALID();
+    auto b_from = ClusterBlockId(movable_blocks_of_type[vtr::irand((int)movable_blocks_of_type.size() - 1)]);
+
+    return b_from;
 }
 
 //Pick a random highly critical block to be swapped with another random block.

vpr/src/place/move_utils.h

@@ -7,7 +7,7 @@
 /* Cut off for incremental bounding box updates.                          *
  * 4 is fastest -- I checked.                                             */
 /* To turn off incremental bounding box updates, set this to a huge value */
-#define SMALL_NET 4
+constexpr size_t SMALL_NET = 4;
 
 /* This is for the placement swap routines. A swap attempt could be       *
  * rejected, accepted or aborted (due to the limitations placed on the    *
@@ -126,6 +126,11 @@ ClusterBlockId propose_block_to_move(const t_placer_opts& placer_opts,
                                      ClusterNetId* net_from,
                                      int* pin_from);
 
+/**
+ * Returns all movable clustered blocks with a specified logical block type.
+ * @param blk_type Specifies the logical block block type.
+ * @return A const reference to a vector containing all movable blocks with the specified logical block type.
+ */
 const std::vector<ClusterBlockId>& movable_blocks_per_type(const t_logical_block_type& blk_type);
 
 /**