equivalent: reorder physical/logical equivalent tiles based on pin differences

This change enables a sorting of the logical block and physical tiles
equivalent counterpart lists based on the differences in the number of pins.

This ordering allows to select the "best" corresponding candidate of a
logical/physical type when there is the need to access its data.

This also allows to not rely on the `pick_random_type` function

Signed-off-by: Alessandro Comodi <[email protected]>

Author: acomodi

libs/libarchfpga/src/read_xml_arch_file.cpp

@@ -4805,8 +4805,24 @@ static void link_physical_logical_types(std::vector<t_physical_tile_type>& Physi
     for (auto& physical_tile : PhysicalTileTypes) {
         if (physical_tile.index == EMPTY_TYPE_INDEX) continue;
 
+        auto& equivalent_sites = physical_tile.equivalent_sites;
+
+        auto criteria = [physical_tile](const t_logical_block_type* lhs, const t_logical_block_type* rhs) {
+            int num_physical_pins = physical_tile.num_pins / physical_tile.capacity;
+
+            int lhs_num_logical_pins = lhs->pb_type->num_pins;
+            int rhs_num_logical_pins = rhs->pb_type->num_pins;
+
+            int lhs_diff_num_pins = num_physical_pins - lhs_num_logical_pins;
+            int rhs_diff_num_pins = num_physical_pins - rhs_num_logical_pins;
+
+            return lhs_diff_num_pins < rhs_diff_num_pins;
+        };
+
+        std::sort(equivalent_sites.begin(), equivalent_sites.end(), criteria);
+
         for (auto& logical_block : LogicalBlockTypes) {
-            for (auto site : physical_tile.equivalent_sites) {
+            for (auto site : equivalent_sites) {
                 if (0 == strcmp(logical_block.name, site->pb_type->name)) {
                     logical_block.equivalent_tiles.push_back(&physical_tile);
 
@@ -4819,14 +4835,30 @@ static void link_physical_logical_types(std::vector<t_physical_tile_type>& Physi
     for (auto& logical_block : LogicalBlockTypes) {
         if (logical_block.index == EMPTY_TYPE_INDEX) continue;
 
-        if ((int)logical_block.equivalent_tiles.size() <= 0) {
+        auto& equivalent_tiles = logical_block.equivalent_tiles;
+
+        if ((int)equivalent_tiles.size() <= 0) {
             archfpga_throw(__FILE__, __LINE__,
                            "Logical Block %s does not have any equivalent tiles.\n", logical_block.name);
         }
 
         std::unordered_map<int, bool> ignored_pins_check_map;
         std::unordered_map<int, bool> global_pins_check_map;
 
+        auto criteria = [logical_block](const t_physical_tile_type* lhs, const t_physical_tile_type* rhs) {
+            int num_logical_pins = logical_block.pb_type->num_pins;
+
+            int lhs_num_physical_pins = lhs->num_pins / lhs->capacity;
+            int rhs_num_physical_pins = rhs->num_pins / rhs->capacity;
+
+            int lhs_diff_num_pins = lhs_num_physical_pins - num_logical_pins;
+            int rhs_diff_num_pins = rhs_num_physical_pins - num_logical_pins;
+
+            return lhs_diff_num_pins < rhs_diff_num_pins;
+        };
+
+        std::sort(equivalent_tiles.begin(), equivalent_tiles.end(), criteria);
+
         for (int pin = 0; pin < logical_block.pb_type->num_pins; pin++) {
             for (auto& tile : logical_block.equivalent_tiles) {
                 auto direct_map = tile->tile_block_pin_directs_map.at(logical_block.index);

vpr/src/base/SetupGrid.cpp

@@ -686,7 +686,7 @@ float calculate_device_utilization(const DeviceGrid& grid, std::map<t_logical_bl
             continue;
         }
 
-        t_physical_tile_type_ptr type = pick_random_physical_type(kv.first);
+        t_physical_tile_type_ptr type = pick_best_physical_type(kv.first);
 
         size_t count = kv.second;
 

vpr/src/base/ShowSetup.cpp

@@ -75,7 +75,7 @@ void printClusteredNetlistStats() {
 
     for (auto blk_id : cluster_ctx.clb_nlist.blocks()) {
         auto logical_block = cluster_ctx.clb_nlist.block_type(blk_id);
-        auto physical_tile = pick_random_physical_type(logical_block);
+        auto physical_tile = pick_best_physical_type(logical_block);
         num_blocks_type[logical_block->index]++;
         if (is_io_type(physical_tile)) {
             for (j = 0; j < logical_block->pb_type->num_pins; j++) {

vpr/src/base/check_netlist.cpp

@@ -92,7 +92,7 @@ static int check_connections_to_global_clb_pins(ClusterNetId net_id, int verbosi
     for (auto pin_id : cluster_ctx.clb_nlist.net_pins(net_id)) {
         ClusterBlockId blk_id = cluster_ctx.clb_nlist.pin_block(pin_id);
         auto logical_type = cluster_ctx.clb_nlist.block_type(blk_id);
-        auto physical_type = pick_random_physical_type(logical_type);
+        auto physical_type = pick_best_physical_type(logical_type);
 
         int log_index = cluster_ctx.clb_nlist.pin_physical_index(pin_id);
         int pin_index = get_physical_pin(physical_type, logical_type, log_index);

vpr/src/base/read_netlist.cpp

@@ -949,7 +949,7 @@ static void load_external_nets_and_cb(ClusteredNetlist& clb_nlist) {
      * and blocks point back to net pins */
     for (auto blk_id : clb_nlist.blocks()) {
         block_type = clb_nlist.block_type(blk_id);
-        auto tile_type = pick_random_physical_type(block_type);
+        auto tile_type = pick_best_physical_type(block_type);
         for (j = 0; j < block_type->pb_type->num_pins; j++) {
             int physical_pin = get_physical_pin(tile_type, block_type, j);
 
@@ -999,7 +999,7 @@ static void load_external_nets_and_cb(ClusteredNetlist& clb_nlist) {
         for (auto pin_id : clb_nlist.net_sinks(net_id)) {
             bool is_ignored_net = clb_nlist.net_is_ignored(net_id);
             block_type = clb_nlist.block_type(clb_nlist.pin_block(pin_id));
-            auto tile_type = pick_random_physical_type(block_type);
+            auto tile_type = pick_best_physical_type(block_type);
             int logical_pin = clb_nlist.pin_logical_index(pin_id);
             int physical_pin = get_physical_pin(tile_type, block_type, logical_pin);
 

vpr/src/base/read_place.cpp

@@ -161,7 +161,7 @@ void read_user_pad_loc(const char* pad_loc_file) {
     hash_table = alloc_hash_table();
     for (auto blk_id : cluster_ctx.clb_nlist.blocks()) {
         auto logical_block = cluster_ctx.clb_nlist.block_type(blk_id);
-        if (is_io_type(pick_random_physical_type(logical_block))) {
+        if (is_io_type(pick_best_physical_type(logical_block))) {
             insert_in_hash_table(hash_table, cluster_ctx.clb_nlist.block_name(blk_id).c_str(), size_t(blk_id));
             place_ctx.block_locs[blk_id].loc.x = OPEN; /* Mark as not seen yet. */
         }
@@ -268,7 +268,7 @@ void read_user_pad_loc(const char* pad_loc_file) {
 
     for (auto blk_id : cluster_ctx.clb_nlist.blocks()) {
         auto logical_block = cluster_ctx.clb_nlist.block_type(blk_id);
-        auto type = pick_random_physical_type(logical_block);
+        auto type = pick_best_physical_type(logical_block);
         if (is_io_type(type) && place_ctx.block_locs[blk_id].loc.x == OPEN) {
             vpr_throw(VPR_ERROR_PLACE_F, pad_loc_file, 0,
                       "IO block %s location was not specified in the pad file.\n", cluster_ctx.clb_nlist.block_name(blk_id).c_str());

vpr/src/draw/draw.cpp

@@ -2736,7 +2736,7 @@ static void draw_reset_blk_color(ClusterBlockId blk_id) {
 
     t_draw_state* draw_state = get_draw_state_vars();
 
-    draw_state->block_color[blk_id] = get_block_type_color(pick_random_physical_type(logical_block));
+    draw_state->block_color[blk_id] = get_block_type_color(pick_best_physical_type(logical_block));
 }
 
 /**

vpr/src/draw/draw_types.cpp

@@ -95,7 +95,7 @@ ezgl::rectangle t_draw_coords::get_absolute_clb_bbox(const ClusterBlockId clb_in
 
 ezgl::rectangle t_draw_coords::get_absolute_clb_bbox(int grid_x, int grid_y, int sub_block_index) {
     auto& device_ctx = g_vpr_ctx.device();
-    return get_pb_bbox(grid_x, grid_y, sub_block_index, *pick_random_logical_type(device_ctx.grid[grid_x][grid_y].type)->pb_graph_head);
+    return get_pb_bbox(grid_x, grid_y, sub_block_index, *pick_best_logical_type(device_ctx.grid[grid_x][grid_y].type)->pb_graph_head);
 }
 
 #endif // NO_GRAPHICS

vpr/src/draw/intra_logic_block.cpp

@@ -96,7 +96,7 @@ void draw_internal_init_blk() {
             continue;
         }
 
-        auto logical_block = pick_random_logical_type(&type);
+        auto logical_block = pick_best_logical_type(&type);
         pb_graph_head_node = logical_block->pb_graph_head;
         int type_descriptor_index = type.index;
 

vpr/src/pack/output_clustering.cpp

@@ -64,7 +64,7 @@ static void print_stats() {
 
     for (auto blk_id : cluster_ctx.clb_nlist.blocks()) {
         auto logical_block = cluster_ctx.clb_nlist.block_type(blk_id);
-        auto physical_tile = pick_random_physical_type(logical_block);
+        auto physical_tile = pick_best_physical_type(logical_block);
         for (ipin = 0; ipin < logical_block->pb_type->num_pins; ipin++) {
             int physical_pin = get_physical_pin(physical_tile, logical_block, ipin);
             auto pin_class = physical_tile->pin_class[physical_pin];

vpr/src/place/initial_placement.cpp

@@ -286,7 +286,7 @@ static void initial_placement_blocks(int* free_locations, enum e_pad_loc_type pa
         auto logical_block = cluster_ctx.clb_nlist.block_type(blk_id);
 
         /* Don't do IOs if the user specifies IOs; we'll read those locations later. */
-        if (!(is_io_type(pick_random_physical_type(logical_block)) && pad_loc_type == USER)) {
+        if (!(is_io_type(pick_best_physical_type(logical_block)) && pad_loc_type == USER)) {
             /* Randomly select a free location of the appropriate type for blk_id.
              * We have a linearized list of all the free locations that can
              * accommodate a block of that type in free_locations[itype].
@@ -317,7 +317,7 @@ static void initial_placement_blocks(int* free_locations, enum e_pad_loc_type pa
             place_ctx.block_locs[blk_id].loc = to;
 
             //Mark IOs as fixed if specifying a (fixed) random placement
-            if (is_io_type(pick_random_physical_type(logical_block)) && pad_loc_type == RANDOM) {
+            if (is_io_type(pick_best_physical_type(logical_block)) && pad_loc_type == RANDOM) {
                 place_ctx.block_locs[blk_id].is_fixed = true;
             }
 

vpr/src/place/place_macro.cpp

@@ -78,7 +78,7 @@ static void find_all_the_macro(int* num_of_macro, std::vector<ClusterBlockId>& p
     num_macro = 0;
     for (auto blk_id : cluster_ctx.clb_nlist.blocks()) {
         auto logical_block = cluster_ctx.clb_nlist.block_type(blk_id);
-        auto physical_tile = pick_random_physical_type(logical_block);
+        auto physical_tile = pick_best_physical_type(logical_block);
 
         num_blk_pins = cluster_ctx.clb_nlist.block_type(blk_id)->pb_type->num_pins;
         for (to_iblk_pin = 0; to_iblk_pin < num_blk_pins; to_iblk_pin++) {

vpr/src/place/uniform_move_generator.cpp

@@ -18,7 +18,7 @@ e_create_move UniformMoveGenerator::propose_move(t_pl_blocks_to_be_moved& blocks
 
     t_pl_loc to;
 
-    auto type = pick_random_physical_type(cluster_from_type);
+    auto type = pick_best_physical_type(cluster_from_type);
 
     if (!find_to_loc_uniform(type, rlim, from, to)) {
         return e_create_move::ABORT;

vpr/src/power/power.cpp

@@ -624,7 +624,7 @@ static void power_usage_blocks(t_power_usage* power_usage) {
                     pb = cluster_ctx.clb_nlist.block_pb(iblk);
                     logical_block = cluster_ctx.clb_nlist.block_type(iblk);
                 } else {
-                    logical_block = pick_random_logical_type(physical_tile);
+                    logical_block = pick_best_logical_type(physical_tile);
                 }
 
                 /* Calculate power of this CLB */

vpr/src/util/vpr_utils.cpp

@@ -317,7 +317,7 @@ std::vector<AtomPinId> find_clb_pin_connected_atom_pins(ClusterBlockId clb, int
     auto& clb_nlist = g_vpr_ctx.clustering().clb_nlist;
 
     auto logical_block = clb_nlist.block_type(clb);
-    auto physical_tile = pick_random_physical_type(logical_block);
+    auto physical_tile = pick_best_physical_type(logical_block);
 
     int physical_pin = get_physical_pin(physical_tile, logical_block, logical_pin);
 
@@ -2151,30 +2151,15 @@ bool is_tile_compatible(t_physical_tile_type_ptr physical_tile, t_logical_block_
     return std::find(equivalent_tiles.begin(), equivalent_tiles.end(), physical_tile) != equivalent_tiles.end();
 }
 
-t_physical_tile_type_ptr pick_random_physical_type(t_logical_block_type_ptr logical_block) {
-    auto equivalent_tiles = logical_block->equivalent_tiles;
-
-    size_t num_equivalent_tiles = equivalent_tiles.size();
-    int index = 0;
-
-    if (num_equivalent_tiles > 1) {
-        index = vtr::irand((int)equivalent_tiles.size() - 1);
-    }
-
-    return equivalent_tiles[index];
+/**
+ * This function returns the most common physical tile type given a logical block
+ */
+t_physical_tile_type_ptr pick_best_physical_type(t_logical_block_type_ptr logical_block) {
+    return logical_block->equivalent_tiles[0];
 }
 
-t_logical_block_type_ptr pick_random_logical_type(t_physical_tile_type_ptr physical_tile) {
-    auto equivalent_sites = physical_tile->equivalent_sites;
-
-    size_t num_equivalent_sites = equivalent_sites.size();
-    int index = 0;
-
-    if (num_equivalent_sites > 1) {
-        index = vtr::irand((int)equivalent_sites.size() - 1);
-    }
-
-    return equivalent_sites[index];
+t_logical_block_type_ptr pick_best_logical_type(t_physical_tile_type_ptr physical_tile) {
+    return physical_tile->equivalent_sites[0];
 }
 
 int get_logical_pin(t_physical_tile_type_ptr physical_tile,

vpr/src/util/vpr_utils.h

@@ -170,8 +170,8 @@ void place_sync_external_block_connections(ClusterBlockId iblk);
 int get_max_num_pins(t_logical_block_type_ptr logical_block);
 
 bool is_tile_compatible(t_physical_tile_type_ptr physical_tile, t_logical_block_type_ptr logical_block);
-t_physical_tile_type_ptr pick_random_physical_type(t_logical_block_type_ptr logical_block);
-t_logical_block_type_ptr pick_random_logical_type(t_physical_tile_type_ptr physical_tile);
+t_physical_tile_type_ptr pick_best_physical_type(t_logical_block_type_ptr logical_block);
+t_logical_block_type_ptr pick_best_logical_type(t_physical_tile_type_ptr physical_tile);
 
 int get_logical_pin(t_physical_tile_type_ptr physical_tile,
                     t_logical_block_type_ptr logical_block,