place: fix equivalent placement issues

In addition now physical_tile_type() and logical_block_type()
returns the highest priority corresponding type

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

Author: acomodi

libs/libarchfpga/src/physical_types.h

@@ -609,8 +609,12 @@ struct t_physical_tile_type {
 
     std::vector<std::string> equivalent_sites_names;
     std::vector<t_logical_block_type_ptr> equivalent_sites;
-    
-    /* Unordered map indexed by the logical block index. 
+
+    /* Map holding the priority for which this logical block needs to be placed.
+     * logical_blocks_priority[priority] -> vector holding the logical_block indices */
+    std::map<int, std::vector<int>> logical_blocks_priority;
+
+    /* Unordered map indexed by the logical block index.
      * tile_block_pin_directs_map[logical block index][logical block pin] -> physical tile pin */
     std::unordered_map<int, std::unordered_map<int, int>> tile_block_pin_directs_map;
 
@@ -669,7 +673,10 @@ struct t_logical_block_type {
     int index = -1; /* index of type descriptor in array (allows for index referencing) */
 
     std::vector<t_physical_tile_type_ptr> equivalent_tiles;
-    std::map<int, std::vector<t_physical_tile_type_ptr>> placement_priority;
+
+    /* Map holding the priority for which this logical block needs to be placed.
+     * physical_tiles_priority[priority] -> vector holding the physical tile indices */
+    std::map<int, std::vector<int>> physical_tiles_priority;
 };
 
 /*************************************************************************************************

libs/libarchfpga/src/read_xml_arch_file.cpp

@@ -2976,6 +2976,8 @@ static void ProcessTiles(pugi::xml_node Node,
 
         t_physical_tile_type PhysicalTileType;
 
+        PhysicalTileType.index = index;
+
         /* Parses the properties fields of the type */
         ProcessTileProps(CurTileType, &PhysicalTileType, loc_data);
 
@@ -3025,8 +3027,6 @@ static void ProcessTiles(pugi::xml_node Node,
         Cur = get_single_child(CurTileType, "equivalent_sites", loc_data, ReqOpt::REQUIRED);
         ProcessTileEquivalentSites(Cur, &PhysicalTileType, LogicalBlockTypes, loc_data);
 
-        PhysicalTileType.index = index;
-
         /* Type fully read */
         ++index;
 
@@ -3217,15 +3217,16 @@ static void ProcessTileEquivalentSites(pugi::xml_node Parent,
     while (CurSite) {
         check_node(CurSite, "site", loc_data);
 
-        expect_only_attributes(CurSite, {"pb_type"}, loc_data);
+        expect_only_attributes(CurSite, {"pb_type", "priority"}, loc_data);
         /* Load equivalent site name */
         auto Prop = std::string(get_attribute(CurSite, "pb_type", loc_data).value());
         PhysicalTileType->equivalent_sites_names.push_back(Prop);
 
         auto LogicalBlockType = get_type_by_name<t_logical_block_type>(Prop.c_str(), LogicalBlockTypes);
 
         auto priority = get_attribute(CurSite, "priority", loc_data, ReqOpt::OPTIONAL).as_int(0);
-        LogicalBlockType->placement_priority[priority].push_back(PhysicalTileType);
+        LogicalBlockType->physical_tiles_priority[priority].push_back(PhysicalTileType->index);
+        PhysicalTileType->logical_blocks_priority[priority].push_back(LogicalBlockType->index);
 
         ProcessEquivalentSiteDirects(CurSite, PhysicalTileType, LogicalBlockType, Prop, loc_data);
 
@@ -4796,8 +4797,7 @@ static void check_port_direct_mappings(t_physical_tile_type_ptr physical_tile, t
         auto block_port = get_port_by_pin(logical_block, pin_map.first);
         auto tile_port = get_port_by_pin(physical_tile, pin_map.second);
 
-        if (0 != strcmp(tile_port->name, block_port->name)
-            || tile_port->type != block_port->type
+        if (tile_port->type != block_port->type
             || tile_port->num_pins != block_port->num_pins
             || tile_port->equivalent != block_port->equivalent) {
             archfpga_throw(__FILE__, __LINE__,
@@ -4832,7 +4832,7 @@ static const t_port* get_port_by_name(t_logical_block_type_ptr type, const char*
 
 static const t_physical_tile_port* get_port_by_pin(t_physical_tile_type_ptr type, int pin) {
     for (auto port : type->ports) {
-        if (pin >= port.absolute_first_pin_index && pin < port.num_pins) {
+        if (pin >= port.absolute_first_pin_index && pin < port.absolute_first_pin_index + port.num_pins) {
             return &type->ports[port.index];
         }
     }
@@ -4845,7 +4845,7 @@ static const t_port* get_port_by_pin(t_logical_block_type_ptr type, int pin) {
 
     for (int i = 0; i < pb_type->num_ports; i++) {
         auto port = pb_type->ports[i];
-        if (pin >= port.absolute_first_pin_index && pin < port.num_pins) {
+        if (pin >= port.absolute_first_pin_index && pin < port.absolute_first_pin_index + port.num_pins) {
             return &pb_type->ports[port.index];
         }
     }

vpr/src/place/move_utils.cpp

@@ -588,7 +588,33 @@ bool find_to_loc_uniform(t_physical_tile_type_ptr type,
             if (cx_from == cx_to && cy_from == cy_to) {
                 continue; //Same from/to location -- try again for new y-position
             } else {
-                legal = true;
+                VTR_ASSERT(cx_to != OPEN);
+                VTR_ASSERT(cy_to != OPEN);
+
+                //Convert to true (uncompressed) grid locations
+                to.x = to_compressed_block_grid.compressed_to_grid_x[cx_to];
+                to.y = to_compressed_block_grid.compressed_to_grid_y[cy_to];
+
+                auto& place_ctx = g_vpr_ctx.placement();
+                auto& cluster_ctx = g_vpr_ctx.clustering();
+
+                auto blocks = place_ctx.grid_blocks[to.x][to.y].blocks;
+                bool impossible_swap = false;
+                for (auto blk : blocks) {
+                    if (blk == ClusterBlockId::INVALID()) {
+                        continue;
+                    }
+
+                    auto block_type = cluster_ctx.clb_nlist.block_type(blk);
+                    if (!is_tile_compatible(from_type, block_type)) {
+                        impossible_swap = true;
+                        break;
+                    }
+                }
+
+                if (!impossible_swap) {
+                    legal = true;
+                }
             }
         }
     }
@@ -598,13 +624,6 @@ bool find_to_loc_uniform(t_physical_tile_type_ptr type,
         return false;
     }
 
-    VTR_ASSERT(cx_to != OPEN);
-    VTR_ASSERT(cy_to != OPEN);
-
-    //Convert to true (uncompressed) grid locations
-    to.x = to_compressed_block_grid.compressed_to_grid_x[cx_to];
-    to.y = to_compressed_block_grid.compressed_to_grid_y[cy_to];
-
     //Each x/y location contains only a single type, so we can pick a random
     //z (capcity) location
     to.z = vtr::irand(type->capacity - 1);

vpr/src/place/place.cpp

@@ -418,7 +418,7 @@ static void placement_inner_loop(float t,
 
 static void recompute_costs_from_scratch(const t_placer_opts& placer_opts, const PlaceDelayModel* delay_model, t_placer_costs* costs);
 
-static t_physical_tile_type_ptr pick_highest_priority_type(t_logical_block_type_ptr logical_block, int num_needed_types, int* free_locations);
+static t_physical_tile_type_ptr pick_highest_placement_priority_type(t_logical_block_type_ptr logical_block, int num_needed_types, int* free_locations);
 
 static void calc_placer_stats(t_placer_statistics& stats, float& success_rat, double& std_dev, const t_placer_costs& costs, const int move_lim);
 
@@ -2410,7 +2410,7 @@ static void initial_placement_pl_macros(int macros_max_num_tries, int* free_loca
         // Assume that all the blocks in the macro are of the same type
         blk_id = pl_macros[imacro].members[0].blk_index;
         auto logical_block = cluster_ctx.clb_nlist.block_type(blk_id);
-        auto type = pick_highest_priority_type(logical_block, int(pl_macros[imacro].members.size()), free_locations);
+        auto type = pick_highest_placement_priority_type(logical_block, int(pl_macros[imacro].members.size()), free_locations);
 
         if (type == nullptr) {
             VPR_FATAL_ERROR(VPR_ERROR_PLACE,
@@ -2488,7 +2488,7 @@ static void initial_placement_blocks(int* free_locations, enum e_pad_loc_type pa
              * that location again, so remove it from the free_locations array.
              */
 
-            auto type = pick_highest_priority_type(logical_block, 1, free_locations);
+            auto type = pick_highest_placement_priority_type(logical_block, 1, free_locations);
 
             if (type == nullptr) {
                 VPR_FATAL_ERROR(VPR_ERROR_PLACE,
@@ -2850,12 +2850,15 @@ int check_macro_placement_consistency() {
     return error;
 }
 
-static t_physical_tile_type_ptr pick_highest_priority_type(t_logical_block_type_ptr logical_block, int num_needed_types, int* free_locations) {
+static t_physical_tile_type_ptr pick_highest_placement_priority_type(t_logical_block_type_ptr logical_block, int num_needed_types, int* free_locations) {
+    auto& device_ctx = g_vpr_ctx.device();
+    auto physical_tiles = device_ctx.physical_tile_types;
+
     // Loop through the ordered map to get tiles in a decreasing priority order
-    for (auto& physical_tiles : logical_block->placement_priority) {
-        for (auto tile : physical_tiles.second) {
-            if (free_locations[tile->index] >= num_needed_types) {
-                return tile;
+    for (auto& physical_tiles_ids : logical_block->physical_tiles_priority) {
+        for (auto tile_id : physical_tiles_ids.second) {
+            if (free_locations[tile_id] >= num_needed_types) {
+                return &physical_tiles[tile_id];
             }
         }
     }

vpr/src/util/vpr_utils.cpp

@@ -646,12 +646,13 @@ bool is_empty_type(t_logical_block_type_ptr type) {
 
 t_physical_tile_type_ptr physical_tile_type(t_logical_block_type_ptr logical_block_type) {
     auto& device_ctx = g_vpr_ctx.device();
+    auto& physical_tiles = device_ctx.physical_tile_types;
 
-    if (0 == logical_block_type->equivalent_tiles.size())
-        return device_ctx.EMPTY_PHYSICAL_TILE_TYPE;
-
-    for (auto type : logical_block_type->equivalent_tiles) {
-        if (0 == strcmp(type->name, logical_block_type->name)) return type;
+    // Loop through the ordered map to get tiles in a decreasing priority order
+    for (auto& physical_tiles_ids : logical_block_type->physical_tiles_priority) {
+        for (auto tile_id : physical_tiles_ids.second) {
+            return &physical_tiles[tile_id];
+        }
     }
 
     return nullptr;
@@ -669,13 +670,15 @@ t_physical_tile_type_ptr physical_tile_type(ClusterBlockId blk) {
 
 t_logical_block_type_ptr logical_block_type(t_physical_tile_type_ptr physical_tile_type) {
     auto& device_ctx = g_vpr_ctx.device();
+    auto& logical_blocks = device_ctx.logical_block_types;
 
-    if (0 == physical_tile_type->equivalent_sites.size())
-        return device_ctx.EMPTY_LOGICAL_BLOCK_TYPE;
-
-    for (auto type : physical_tile_type->equivalent_sites) {
-        if (0 == strcmp(type->name, physical_tile_type->name)) return type;
+    // Loop through the ordered map to get tiles in a decreasing priority order
+    for (auto& logical_blocks_ids : physical_tile_type->logical_blocks_priority) {
+        for (auto block_id : logical_blocks_ids.second) {
+            return &logical_blocks[block_id];
+        }
     }
+
     return nullptr;
 }