make place_sync_external_block_connections() and set_block_location() methods of BlkLocRegistry

Author: soheilshahrouz

vpr/src/base/blk_loc_registry.cpp

@@ -38,3 +38,78 @@ int BlkLocRegistry::net_pin_to_tile_pin_index(const ClusterNetId net_id, int net
 
     return this->tile_pin_index(pin_id);
 }
+
+void BlkLocRegistry::set_block_location(ClusterBlockId blk_id, const t_pl_loc& location) {
+    auto& device_ctx = g_vpr_ctx.device();
+    auto& cluster_ctx = g_vpr_ctx.clustering();
+
+    const std::string& block_name = cluster_ctx.clb_nlist.block_name(blk_id);
+
+    //Check if block location is out of range of grid dimensions
+    if (location.x < 0 || location.x > int(device_ctx.grid.width() - 1)
+        || location.y < 0 || location.y > int(device_ctx.grid.height() - 1)) {
+        VPR_THROW(VPR_ERROR_PLACE, "Block %s with ID %d is out of range at location (%d, %d). \n",
+                  block_name.c_str(), blk_id, location.x, location.y);
+    }
+
+    //Set the location of the block
+    block_locs_[blk_id].loc = location;
+
+    //Check if block is at an illegal location
+    auto physical_tile = device_ctx.grid.get_physical_type({location.x, location.y, location.layer});
+    auto logical_block = cluster_ctx.clb_nlist.block_type(blk_id);
+
+    if (location.sub_tile >= physical_tile->capacity || location.sub_tile < 0) {
+        VPR_THROW(VPR_ERROR_PLACE, "Block %s subtile number (%d) is out of range. \n", block_name.c_str(), location.sub_tile);
+    }
+
+    if (!is_sub_tile_compatible(physical_tile, logical_block, block_locs_[blk_id].loc.sub_tile)) {
+        VPR_THROW(VPR_ERROR_PLACE, "Attempt to place block %s with ID %d at illegal location (%d,%d,%d). \n",
+                  block_name.c_str(),
+                  blk_id,
+                  location.x,
+                  location.y,
+                  location.layer);
+    }
+
+    //Mark the grid location and usage of the block
+    grid_blocks_.set_block_at_location(location, blk_id);
+    grid_blocks_.set_usage({location.x, location.y, location.layer},
+                          grid_blocks_.get_usage({location.x, location.y, location.layer}) + 1);
+
+    place_sync_external_block_connections(blk_id);
+}
+
+void BlkLocRegistry::place_sync_external_block_connections(ClusterBlockId iblk) {
+    const auto& cluster_ctx = g_vpr_ctx.clustering();
+    const auto& clb_nlist = cluster_ctx.clb_nlist;
+
+    t_pl_loc block_loc = block_locs_[iblk].loc;
+
+    auto physical_tile = physical_tile_type(block_loc);
+    auto logical_block = clb_nlist.block_type(iblk);
+
+    int sub_tile_index = get_sub_tile_index(iblk, block_locs_);
+    auto sub_tile = physical_tile->sub_tiles[sub_tile_index];
+
+    VTR_ASSERT(sub_tile.num_phy_pins % sub_tile.capacity.total() == 0);
+
+    int max_num_block_pins = sub_tile.num_phy_pins / sub_tile.capacity.total();
+    /* Logical location and physical location is offset by z * max_num_block_pins */
+
+    int rel_capacity = block_loc.sub_tile - sub_tile.capacity.low;
+
+    for (ClusterPinId pin : clb_nlist.block_pins(iblk)) {
+        int logical_pin_index = clb_nlist.pin_logical_index(pin);
+        int sub_tile_pin_index = get_sub_tile_physical_pin(sub_tile_index, physical_tile, logical_block, logical_pin_index);
+
+        int new_physical_pin_index = sub_tile.sub_tile_to_tile_pin_indices[sub_tile_pin_index + rel_capacity * max_num_block_pins];
+
+        auto result = physical_pins_.find(pin);
+        if (result != physical_pins_.end()) {
+            physical_pins_[pin] = new_physical_pin_index;
+        } else {
+            physical_pins_.insert(pin, new_physical_pin_index);
+        }
+    }
+}

vpr/src/base/blk_loc_registry.h

@@ -51,6 +51,35 @@ class BlkLocRegistry {
 
     ///@brief Returns the physical pin of the tile, related to the given ClusterNedId, and the net pin index.
     int net_pin_to_tile_pin_index(const ClusterNetId net_id, int net_pin_index) const;
+
+    /**
+     * @brief Performs error checking to see if location is legal for block type,
+     * and sets the location and grid usage of the block if it is legal.
+     * @param blk_id The unique ID of the clustered block whose location is to set.
+     * @param location The location where the clustered block should placed at.
+     */
+    void set_block_location(ClusterBlockId blk_id, const t_pl_loc& location);
+
+    /**
+     * @brief Syncs the logical block pins corresponding to the input iblk with the corresponding chosen physical tile
+     * @param iblk cluster block ID to sync within the assigned physical tile
+     *
+     * This routine updates the physical pins vector of the place context after the placement step
+     * to synchronize the pins related to the logical block with the actual connection interface of
+     * the belonging physical tile with the RR graph.
+     *
+     * This step is required as the logical block can be placed at any compatible sub tile locations
+     * within a physical tile.
+     * Given that it is possible to have equivalent logical blocks within a specific sub tile, with
+     * a different subset of IO pins, the various pins offsets must be correctly computed and assigned
+     * to the physical pins vector, so that, when the net RR terminals are computed, the correct physical
+     * tile IO pins are selected.
+     *
+     * This routine uses the x,y and sub_tile coordinates of the clb netlist, and expects those to place each netlist block
+     * at a legal location that can accommodate it.
+     * It does not check for overuse of locations, therefore it can be used with placements that have resource overuse.
+     */
+    void place_sync_external_block_connections(ClusterBlockId iblk);
 };
 
 #endif //VTR_BLK_LOC_REGISTRY_H

vpr/src/base/place_and_route.cpp

@@ -580,6 +580,6 @@ void post_place_sync() {
 
     // Cluster-based netlist is used for placement
     for (const ClusterBlockId block_id : cluster_ctx.clb_nlist.blocks()) {
-        place_sync_external_block_connections(block_id, blk_loc_registry);
+        blk_loc_registry.place_sync_external_block_connections(block_id);
     }
 }

vpr/src/base/read_place.cpp

@@ -314,7 +314,7 @@ static std::string read_place_body(std::ifstream& placement_file,
                         blk_id, loc.x, loc.y, loc.layer, loc.sub_tile, constraint_loc.x, constraint_loc.y, constraint_loc.layer, constraint_loc.sub_tile);
                     }
                 }
-                set_block_location(blk_id, loc, blk_loc_registry);
+                blk_loc_registry.set_block_location(blk_id, loc);
             }
 
             //need to lock down blocks if it is a constraints file

vpr/src/place/initial_placement.cpp

@@ -890,7 +890,7 @@ bool try_place_macro(const t_pl_macro& pl_macro,
         for (const t_pl_macro_member& pl_macro_member : pl_macro.members) {
             t_pl_loc member_pos = head_pos + pl_macro_member.offset;
             ClusterBlockId iblk = pl_macro_member.blk_index;
-            set_block_location(iblk, member_pos, blk_loc_registry);
+            blk_loc_registry.set_block_location(iblk, member_pos);
         } // Finish placing all the members in the macro
     }
 

vpr/src/place/move_transactions.cpp

@@ -90,7 +90,7 @@ void apply_move_blocks(const t_pl_blocks_to_be_moved& blocks_affected,
 
         //if physical tile type of old location does not equal physical tile type of new location, sync the new physical pins
         if (old_type != new_type) {
-            place_sync_external_block_connections(blk, blk_loc_registry);
+            blk_loc_registry.place_sync_external_block_connections(blk);
         }
     }
 }
@@ -147,7 +147,7 @@ void revert_move_blocks(const t_pl_blocks_to_be_moved& blocks_affected,
 
         //if physical tile type of old location does not equal physical tile type of new location, sync the new physical pins
         if (old_type != new_type) {
-            place_sync_external_block_connections(blk, blk_loc_registry);
+            blk_loc_registry.place_sync_external_block_connections(blk);
         }
 
         VTR_ASSERT_SAFE_MSG(blk_loc_registry.grid_blocks().block_at_location(old_loc) == blk,

vpr/src/place/noc_place_checkpoint.cpp

@@ -60,7 +60,7 @@ void NoCPlacementCheckpoint::restore_checkpoint(t_placer_costs& costs,
 
     // Place routers based on router_locations_
     for (const auto& [router_blk_id, location] : router_locations_) {
-        set_block_location(router_blk_id, location, blk_loc_registry);
+        blk_loc_registry.set_block_location(router_blk_id, location);
     }
 
     // Re-initialize routes and static variables that keep track of NoC-related costs

vpr/src/place/place.cpp

@@ -475,7 +475,7 @@ void try_place(const Netlist<>& net_list,
 
     // Update physical pin values
     for (const ClusterBlockId block_id : cluster_ctx.clb_nlist.blocks()) {
-        place_sync_external_block_connections(block_id, blk_loc_registry);
+        blk_loc_registry.place_sync_external_block_connections(block_id);
     }
 
     const int width_fac = placer_opts.place_chan_width;
@@ -903,7 +903,7 @@ void try_place(const Netlist<>& net_list,
 
     // Update physical pin values
     for (const ClusterBlockId block_id : cluster_ctx.clb_nlist.blocks()) {
-        place_sync_external_block_connections(block_id, blk_loc_registry);
+        blk_loc_registry.place_sync_external_block_connections(block_id);
     }
 
     check_place(costs,

vpr/src/place/place_constraints.cpp

@@ -270,7 +270,7 @@ void mark_fixed_blocks(BlkLocRegistry& blk_loc_registry) {
          * and mark it as fixed.
          */
         if (is_pr_size_one(pr, block_type, loc)) {
-            set_block_location(blk_id, loc, blk_loc_registry);
+            blk_loc_registry.set_block_location(blk_id, loc);
             blk_loc_registry.mutable_block_locs()[blk_id].is_fixed = true;
         }
     }

vpr/src/place/place_util.cpp

@@ -356,51 +356,6 @@ void alloc_and_load_legal_placement_locations(std::vector<std::vector<std::vecto
     legal_pos.shrink_to_fit();
 }
 
-void set_block_location(ClusterBlockId blk_id,
-                        const t_pl_loc& location,
-                        BlkLocRegistry& blk_loc_registry) {
-    auto& device_ctx = g_vpr_ctx.device();
-    auto& cluster_ctx = g_vpr_ctx.clustering();
-    auto& block_locs = blk_loc_registry.mutable_block_locs();
-    auto& grid_blocks = blk_loc_registry.mutable_grid_blocks();
-
-    const std::string& block_name = cluster_ctx.clb_nlist.block_name(blk_id);
-
-    //Check if block location is out of range of grid dimensions
-    if (location.x < 0 || location.x > int(device_ctx.grid.width() - 1)
-        || location.y < 0 || location.y > int(device_ctx.grid.height() - 1)) {
-        VPR_THROW(VPR_ERROR_PLACE, "Block %s with ID %d is out of range at location (%d, %d). \n",
-                  block_name.c_str(), blk_id, location.x, location.y);
-    }
-
-    //Set the location of the block
-    block_locs[blk_id].loc = location;
-
-    //Check if block is at an illegal location
-    auto physical_tile = device_ctx.grid.get_physical_type({location.x, location.y, location.layer});
-    auto logical_block = cluster_ctx.clb_nlist.block_type(blk_id);
-
-    if (location.sub_tile >= physical_tile->capacity || location.sub_tile < 0) {
-        VPR_THROW(VPR_ERROR_PLACE, "Block %s subtile number (%d) is out of range. \n", block_name.c_str(), location.sub_tile);
-    }
-
-    if (!is_sub_tile_compatible(physical_tile, logical_block, block_locs[blk_id].loc.sub_tile)) {
-        VPR_THROW(VPR_ERROR_PLACE, "Attempt to place block %s with ID %d at illegal location (%d,%d,%d). \n",
-                  block_name.c_str(),
-                  blk_id,
-                  location.x,
-                  location.y,
-                  location.layer);
-    }
-
-    //Mark the grid location and usage of the block
-    grid_blocks.set_block_at_location(location, blk_id);
-    grid_blocks.set_usage({location.x, location.y, location.layer},
-                          grid_blocks.get_usage({location.x, location.y, location.layer}) + 1);
-
-    place_sync_external_block_connections(blk_id, blk_loc_registry);
-}
-
 bool macro_can_be_placed(const t_pl_macro& pl_macro,
                          const t_pl_loc& head_pos,
                          bool check_all_legality,
@@ -492,40 +447,3 @@ NocCostTerms& NocCostTerms::operator+=(const NocCostTerms& noc_delta_cost) {
 
     return *this;
 }
-
-void place_sync_external_block_connections(ClusterBlockId iblk,
-                                           BlkLocRegistry& blk_loc_registry) {
-    const auto& cluster_ctx = g_vpr_ctx.clustering();
-    const auto& clb_nlist = cluster_ctx.clb_nlist;
-    const auto& block_locs = blk_loc_registry.block_locs();
-    auto& physical_pins = blk_loc_registry.mutable_physical_pins();
-
-    t_pl_loc block_loc = block_locs[iblk].loc;
-
-    auto physical_tile = physical_tile_type(block_loc);
-    auto logical_block = clb_nlist.block_type(iblk);
-
-    int sub_tile_index = get_sub_tile_index(iblk, block_locs);
-    auto sub_tile = physical_tile->sub_tiles[sub_tile_index];
-
-    VTR_ASSERT(sub_tile.num_phy_pins % sub_tile.capacity.total() == 0);
-
-    int max_num_block_pins = sub_tile.num_phy_pins / sub_tile.capacity.total();
-    /* Logical location and physical location is offset by z * max_num_block_pins */
-
-    int rel_capacity = block_loc.sub_tile - sub_tile.capacity.low;
-
-    for (ClusterPinId pin : clb_nlist.block_pins(iblk)) {
-        int logical_pin_index = clb_nlist.pin_logical_index(pin);
-        int sub_tile_pin_index = get_sub_tile_physical_pin(sub_tile_index, physical_tile, logical_block, logical_pin_index);
-
-        int new_physical_pin_index = sub_tile.sub_tile_to_tile_pin_indices[sub_tile_pin_index + rel_capacity * max_num_block_pins];
-
-        auto result = physical_pins.find(pin);
-        if (result != physical_pins.end()) {
-            physical_pins[pin] = new_physical_pin_index;
-        } else {
-            physical_pins.insert(pin, new_physical_pin_index);
-        }
-    }
-}

vpr/src/place/place_util.h

@@ -352,12 +352,6 @@ void load_grid_blocks_from_block_locs(GridBlock& grid_blocks,
  */
 void alloc_and_load_legal_placement_locations(std::vector<std::vector<std::vector<t_pl_loc>>>& legal_pos);
 
-///@brief Performs error checking to see if location is legal for block type,
-/// and sets the location and grid usage of the block if it is legal.
-void set_block_location(ClusterBlockId blk_id,
-                        const t_pl_loc& location,
-                        BlkLocRegistry& blk_loc_registry);
-
 /// @brief check if a specified location is within the device grid
 inline bool is_loc_on_chip(t_physical_tile_loc loc) {
     const auto& grid = g_vpr_ctx.device().grid;
@@ -396,27 +390,4 @@ bool macro_can_be_placed(const t_pl_macro& pl_macro,
                          const t_pl_loc& head_pos,
                          bool check_all_legality,
                          const BlkLocRegistry& blk_loc_registry);
-
-/**
- * @brief Syncs the logical block pins corresponding to the input iblk with the corresponding chosen physical tile
- * @param iblk cluster block ID to sync within the assigned physical tile
- * @param blk_loc_registry Placement block location information. To be updated with new pin mapping info.
- *
- * This routine updates the physical pins vector of the place context after the placement step
- * to synchronize the pins related to the logical block with the actual connection interface of
- * the belonging physical tile with the RR graph.
- *
- * This step is required as the logical block can be placed at any compatible sub tile locations
- * within a physical tile.
- * Given that it is possible to have equivalent logical blocks within a specific sub tile, with
- * a different subset of IO pins, the various pins offsets must be correctly computed and assigned
- * to the physical pins vector, so that, when the net RR terminals are computed, the correct physical
- * tile IO pins are selected.
- *
- * This routine uses the x,y and sub_tile coordinates of the clb netlist, and expects those to place each netlist block
- * at a legal location that can accommodate it.
- * It does not check for overuse of locations, therefore it can be used with placements that have resource overuse.
- */
-void place_sync_external_block_connections(ClusterBlockId iblk,
-                                           BlkLocRegistry& blk_loc_registry);
 #endif