equivalent tiles: updated placer to swap in equivalent tile locations

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

Author: acomodi

vpr/src/place/place.cpp

@@ -287,7 +287,7 @@ static void comp_td_costs(const PlaceDelayModel& delay_model, float *timing_cost
 
 static e_swap_result assess_swap(float delta_c, float t);
 
-static bool find_to(t_type_ptr type, float rlim,
+static bool find_to(ClusterBlockId blk, t_type_ptr type, float rlim,
 		int x_from, int y_from,
 		int *px_to, int *py_to, int *pz_to);
 static void find_to_location(t_type_ptr type, float rlim,
@@ -1225,14 +1225,19 @@ static int setup_blocks_affected(ClusterBlockId b_from, int x_to, int y_to, int
 	ClusterBlockId b_to;
 	int abort_swap = false;
 
-    auto& place_ctx = g_vpr_ctx.mutable_placement();
+	auto& place_ctx = g_vpr_ctx.mutable_placement();
+	auto clb_nlist = g_vpr_ctx.clustering().clb_nlist;
+	auto grid = g_vpr_ctx.device().grid;
 
 	x_from = place_ctx.block_locs[b_from].x;
 	y_from = place_ctx.block_locs[b_from].y;
 	z_from = place_ctx.block_locs[b_from].z;
 
 	b_to = place_ctx.grid_blocks[x_to][y_to].blocks[z_to];
 
+	auto cluster_to_type = clb_nlist.block_type(b_to);
+	auto grid_from_type = grid[x_from][y_from].type;
+
 	// Check whether the to_location is empty
 	if (b_to == EMPTY_BLOCK_ID) {
 
@@ -1254,7 +1259,8 @@ static int setup_blocks_affected(ClusterBlockId b_from, int x_to, int y_to, int
 		blocks_affected.moved_blocks[imoved_blk].swapped_from_is_empty = true;
 		blocks_affected.num_moved_blocks ++;
 
-	} else if (b_to != INVALID_BLOCK_ID) {
+	// If location is not empty checks that the block in the `to` location is compatible with the `from` location
+	} else if (b_to != INVALID_BLOCK_ID && check_if_legal_placement(cluster_to_type, grid_from_type)) {
 
 		// Does not allow a swap with a macro yet
 		get_imacro_from_iblk(&imacro, b_to, pl_macros, num_pl_macros);
@@ -1285,6 +1291,7 @@ static int setup_blocks_affected(ClusterBlockId b_from, int x_to, int y_to, int
 		blocks_affected.moved_blocks[imoved_blk].swapped_from_is_empty = false;
 		blocks_affected.num_moved_blocks ++;
 
+		// Finish swapping the blocks and setting up blocks_affected
 		imoved_blk = blocks_affected.num_moved_blocks;
 		blocks_affected.moved_blocks[imoved_blk].block_num = b_to;
 		blocks_affected.moved_blocks[imoved_blk].xold = x_to;
@@ -1296,8 +1303,10 @@ static int setup_blocks_affected(ClusterBlockId b_from, int x_to, int y_to, int
 		blocks_affected.moved_blocks[imoved_blk].swapped_to_was_empty = false;
 		blocks_affected.moved_blocks[imoved_blk].swapped_from_is_empty = false;
 		blocks_affected.num_moved_blocks ++;
-
-	} // Finish swapping the blocks and setting up blocks_affected
+	} else {
+		abort_swap = true;
+		return (abort_swap);
+	}
 
 	return (abort_swap);
 
@@ -1355,7 +1364,7 @@ static int find_affected_blocks(ClusterBlockId b_from, int x_to, int y_to, int z
 			if (   curr_x_to < 1 || curr_x_to >= int(device_ctx.grid.width())
                 || curr_y_to < 1 || curr_y_to >= int(device_ctx.grid.height())
                 || curr_z_to < 0
-                || device_ctx.grid[curr_x_to][curr_y_to].type != cluster_ctx.clb_nlist.block_type(curr_b_from)) {
+                || !check_if_legal_placement(cluster_ctx.clb_nlist.block_type(curr_b_from), device_ctx.grid[curr_x_to][curr_y_to].type)) {
 				abort_swap = true;
 			} else {
 				abort_swap = setup_blocks_affected(curr_b_from, curr_x_to, curr_y_to, curr_z_to);
@@ -1418,8 +1427,16 @@ static e_swap_result try_swap(float t,
 
     VTR_ASSERT(check_if_legal_placement(cluster_from_type, grid_from_type));
 
-    if (!find_to(cluster_ctx.clb_nlist.block_type(b_from), rlim, x_from, y_from, &x_to, &y_to, &z_to))
+    t_type_ptr to_block_type = cluster_ctx.clb_nlist.block_type(b_from);
+    int rand_block_type = vtr::irand(to_block_type->num_equivalent_tiles);
+    if (rand_block_type != 0) {
+        to_block_type = to_block_type->equivalent_tiles[rand_block_type-1];
+    }
+
+
+    if (!find_to(b_from, to_block_type, rlim, x_from, y_from, &x_to, &y_to, &z_to)) {
         return REJECTED;
+    }
 
 #if 0
     auto& grid = g_vpr_ctx.device().grid;
@@ -1535,6 +1552,7 @@ static e_swap_result try_swap(float t,
 				place_ctx.block_locs[b_from].y = blocks_affected.moved_blocks[iblk].yold;
 				place_ctx.block_locs[b_from].z = blocks_affected.moved_blocks[iblk].zold;
 			}
+
 		}
 
 		/* Resets the num_moved_blocks, but do not free blocks_moved array. Defensive Coding */
@@ -1730,7 +1748,7 @@ static void update_td_delta_costs(const PlaceDelayModel& delay_model, const Clus
     }
 }
 
-static bool find_to(t_type_ptr type, float rlim,
+static bool find_to(ClusterBlockId blk, t_type_ptr type, float rlim,
 		int x_from, int y_from,
 		int *px_to, int *py_to, int *pz_to) {
 
@@ -1745,11 +1763,11 @@ static bool find_to(t_type_ptr type, float rlim,
 	bool is_legal;
 	int itype;
 
-    auto& grid = g_vpr_ctx.device().grid;
-    auto& place_ctx = g_vpr_ctx.placement();
+	auto& grid = g_vpr_ctx.device().grid;
+	auto& place_ctx = g_vpr_ctx.placement();
 
-    auto grid_type = grid[x_from][y_from].type;
-	VTR_ASSERT(check_if_legal_placement(type, grid_type));
+	auto cluster_type = g_vpr_ctx.clustering().clb_nlist.block_type(blk);
+	VTR_ASSERT(check_if_legal_placement(cluster_type, type));
 
 	int rlx = min<float>(grid.width() - 1, rlim);
 	int rly = min<float>(grid.height() - 1, rlim); /* Added rly for aspect_ratio != 1 case. */
@@ -1788,7 +1806,7 @@ static bool find_to(t_type_ptr type, float rlim,
 			is_legal = false;
 		} else if(*px_to > max_x || *px_to < min_x || *py_to > max_y || *py_to < min_y) {
 			is_legal = false;
-		} else if(grid[*px_to][*py_to].type != grid[x_from][y_from].type) {
+		} else if(!check_if_legal_placement(cluster_type, grid[*px_to][*py_to].type)) {
 			is_legal = false;
 		} else {
 			/* Find z_to and test to validate that the "to" block is *not* fixed */
@@ -1810,7 +1828,7 @@ static bool find_to(t_type_ptr type, float rlim,
 		vpr_throw(VPR_ERROR_PLACE, __FILE__, __LINE__,"in routine find_to: (x_to,y_to) = (%d,%d)\n", *px_to, *py_to);
 	}
 
-	VTR_ASSERT(check_if_legal_placement(type, grid[*px_to][*py_to].type));
+	VTR_ASSERT(check_if_legal_placement(cluster_type, grid[*px_to][*py_to].type));
 	return true;
 }
 
@@ -1834,19 +1852,23 @@ static void find_to_location(t_type_ptr type, float rlim,
 	int max_y = min<float>(grid.height() - 1, y_from + rly);
 
 	*pz_to = 0;
-	if (int(grid.width() / 4) < rlx || int(grid.height() / 4) < rly || num_legal_pos[itype] < active_area) {
+
+	// TODO: Must check how to find a new location now that we have equivalent tiles.
+	// XXX: Lines which are commented out prevented to find equivalent tiles to swap with. They are temporarily disabled
+
+//	if (int(grid.width() / 4) < rlx || int(grid.height() / 4) < rly || num_legal_pos[itype] < active_area) {
 		int ipos = vtr::irand(num_legal_pos[itype] - 1);
 		*px_to = legal_pos[itype][ipos].x;
 		*py_to = legal_pos[itype][ipos].y;
 		*pz_to = legal_pos[itype][ipos].z;
-	} else {
-		int x_rel = vtr::irand(max(0, max_x - min_x));
-		int y_rel = vtr::irand(max(0, max_y - min_y));
-		*px_to = min_x + x_rel;
-		*py_to = min_y + y_rel;
-		*px_to = (*px_to) - grid[*px_to][*py_to].width_offset; /* align it */
-		*py_to = (*py_to) - grid[*px_to][*py_to].height_offset; /* align it */
-	}
+//	} else {
+//		int x_rel = vtr::irand(max(0, max_x - min_x));
+//		int y_rel = vtr::irand(max(0, max_y - min_y));
+//		*px_to = min_x + x_rel;
+//		*py_to = min_y + y_rel;
+//		*px_to = (*px_to) - grid[*px_to][*py_to].width_offset; /* align it */
+//		*py_to = (*py_to) - grid[*px_to][*py_to].height_offset; /* align it */
+//	}
 }
 
 static e_swap_result assess_swap(float delta_c, float t) {
@@ -3388,6 +3410,10 @@ static std::vector<int> get_available_placement_itypes(t_type_ptr type) {
 }
 
 static bool check_if_legal_placement(t_type_ptr cluster_type, t_type_ptr grid_type) {
+	if (cluster_type->index == grid_type->index) {
+		return true;
+	}
+
     std::vector<int> itypes = get_available_placement_itypes(cluster_type);
 	if (std::find(itypes.begin(), itypes.end(), grid_type->index) != itypes.end()) {
 		return true;