equivalent tiles: updated placer to use equivalent tile locations

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

Author: acomodi

vpr/src/place/place.cpp

@@ -287,12 +287,12 @@ 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(t_type_ptr from_type, t_type_ptr to_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,
 		int x_from, int y_from,
-		int *px_to, int *py_to, int *pz_to);
+		int *px_to, int *py_to, int *pz_to, bool is_equivalent);
 
 static void get_non_updateable_bb(ClusterNetId net_id, t_bb *bb_coord_new);
 
@@ -353,8 +353,6 @@ static void generate_post_place_timing_reports(const t_placer_opts& placer_opts,
                                                const SetupTimingInfo& timing_info,
                                                const PlacementDelayCalculator& delay_calc);
 
-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);
 /*****************************************************************************/
 void try_place(t_placer_opts placer_opts,
 		t_annealing_sched annealing_sched,
@@ -1233,6 +1231,8 @@ static int setup_blocks_affected(ClusterBlockId b_from, int x_to, int y_to, int
 
 	b_to = place_ctx.grid_blocks[x_to][y_to].blocks[z_to];
 
+	t_type_ptr cluster_to_type = g_vpr_ctx.clustering().clb_nlist.block_type(b_to);
+	t_type_ptr grid_from_type = g_vpr_ctx.device().grid[x_from][y_from].type;
 	// Check whether the to_location is empty
 	if (b_to == EMPTY_BLOCK_ID) {
 
@@ -1254,7 +1254,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 = true;
 		blocks_affected.num_moved_blocks ++;
 
-	} else if (b_to != INVALID_BLOCK_ID) {
+	} else if (b_to != INVALID_BLOCK_ID && cluster_to_type->is_available_tile_index(grid_from_type->index)) {
 
 		// Does not allow a swap with a macro yet
 		get_imacro_from_iblk(&imacro, b_to, pl_macros, num_pl_macros);
@@ -1297,7 +1297,10 @@ 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
+	} else {
+		abort_swap = true;
+		return (abort_swap);
+	}// Finish swapping the blocks and setting up blocks_affected
 
 	return (abort_swap);
 
@@ -1355,7 +1358,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)) {
+                || !cluster_ctx.clb_nlist.block_type(curr_b_from)->is_available_tile_index(device_ctx.grid[curr_x_to][curr_y_to].type->index)) {
 				abort_swap = true;
 			} else {
 				abort_swap = setup_blocks_affected(curr_b_from, curr_x_to, curr_y_to, curr_z_to);
@@ -1415,11 +1418,18 @@ static e_swap_result try_swap(float t,
 
     auto cluster_from_type = cluster_ctx.clb_nlist.block_type(b_from);
     auto grid_from_type = g_vpr_ctx.device().grid[x_from][y_from].type;
+    VTR_ASSERT(cluster_from_type->is_available_tile_index(grid_from_type->index));
 
-    VTR_ASSERT(check_if_legal_placement(cluster_from_type, grid_from_type));
+	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(cluster_ctx.clb_nlist.block_type(b_from), rlim, x_from, y_from, &x_to, &y_to, &z_to))
-        return REJECTED;
+    VTR_ASSERT(cluster_from_type->is_available_tile_index(to_block_type->index));
+
+	if (!find_to(cluster_from_type, 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;
@@ -1449,7 +1459,7 @@ static e_swap_result try_swap(float t,
 
 		// Find all the nets affected by this swap and update thier bounding box
 		int num_nets_affected = find_affected_nets_and_update_costs(place_algorithm, delay_model, bb_delta_c, timing_delta_c, delay_delta_c);
-
+			
 		if (place_algorithm == PATH_TIMING_DRIVEN_PLACE) {
 			/*in this case we redefine delta_c as a combination of timing and bb.  *
 			 *additionally, we normalize all values, therefore delta_c is in       *
@@ -1730,7 +1740,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(t_type_ptr from_type, t_type_ptr to_type, float rlim,
 		int x_from, int y_from,
 		int *px_to, int *py_to, int *pz_to) {
 
@@ -1747,9 +1757,7 @@ static bool find_to(t_type_ptr type, float rlim,
 
     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_ctx = g_vpr_ctx.clustering();
 
 	int rlx = min<float>(grid.width() - 1, rlim);
 	int rly = min<float>(grid.height() - 1, rlim); /* Added rly for aspect_ratio != 1 case. */
@@ -1768,27 +1776,27 @@ static bool find_to(t_type_ptr type, float rlim,
 	}
 
 	num_tries = 0;
-	itype = type->index;
+	itype = to_type->index;
 
 	do { /* Until legal */
 		is_legal = true;
 
 		/* Limit the number of tries when searching for an alternative position */
-		if(num_tries >= 2 * min(active_area / (type->width * type->height), num_legal_pos[itype]) + 10) {
+		if(num_tries >= 2 * min(active_area / (to_type->width * to_type->height), num_legal_pos[itype]) + 10) {
 			/* Tried randomly searching for a suitable position */
 			return false;
 		} else {
 			num_tries++;
 		}
 
-		find_to_location(type, rlim, x_from, y_from,
-				px_to, py_to, pz_to);
+		find_to_location(to_type, rlim, x_from, y_from,
+				px_to, py_to, pz_to, from_type != to_type);
 
 		if((x_from == *px_to) && (y_from == *py_to)) {
 			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(to_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 */
@@ -1797,7 +1805,11 @@ static bool find_to(t_type_ptr type, float rlim,
 				*pz_to = vtr::irand(grid[*px_to][*py_to].type->capacity - 1);
 			}
 			ClusterBlockId b_to = place_ctx.grid_blocks[*px_to][*py_to].blocks[*pz_to];
-			if ((b_to != EMPTY_BLOCK_ID) && (place_ctx.block_locs[b_to].is_fixed == true)) {
+			auto b_to_type = cluster_ctx.clb_nlist.block_type(b_to);
+			auto grid_from_type = grid[x_from][y_from].type;
+
+			if (b_to != EMPTY_BLOCK_ID &&
+				((place_ctx.block_locs[b_to].is_fixed == true) || (!b_to_type->is_available_tile_index(grid_from_type->index)))) {
 				is_legal = false;
 			}
 		}
@@ -1810,13 +1822,13 @@ 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(from_type->is_available_tile_index(grid[*px_to][*py_to].type->index));
 	return true;
 }
 
 static void find_to_location(t_type_ptr type, float rlim,
 		int x_from, int y_from,
-		int *px_to, int *py_to, int *pz_to) {
+		int *px_to, int *py_to, int *pz_to, bool is_equivalent) {
 
     auto& device_ctx = g_vpr_ctx.device();
     auto& grid = device_ctx.grid;
@@ -1834,7 +1846,7 @@ 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) {
+	if (int(grid.width() / 4) < rlx || int(grid.height() / 4) < rly || num_legal_pos[itype] < active_area || is_equivalent) {
 		int ipos = vtr::irand(num_legal_pos[itype] - 1);
 		*px_to = legal_pos[itype][ipos].x;
 		*py_to = legal_pos[itype][ipos].y;
@@ -2848,7 +2860,7 @@ static void initial_placement_pl_macros(int macros_max_num_tries, int * free_loc
 
 		bool no_free_locations = true;
 		// Loop over all the possible equivalent tiles
-		for (int itype : get_available_placement_itypes(cluster_ctx.clb_nlist.block_type(blk_id))) {
+		for (int itype : cluster_ctx.clb_nlist.block_type(blk_id)->available_tiles_indices) {
 			if (free_locations[itype] >= pl_macros[imacro].num_blocks) {
 				no_free_locations = false;
 			} else {
@@ -2935,7 +2947,7 @@ static void initial_placement_blocks(int * free_locations, enum e_pad_loc_type p
 			 */
 			bool no_free_locations = true;
 			// Loop over all the possible equivalent tiles
-			for (int itype : get_available_placement_itypes(cluster_ctx.clb_nlist.block_type(blk_id))) {
+			for (int itype : cluster_ctx.clb_nlist.block_type(blk_id)->available_tiles_indices) {
 				if (free_locations[itype] > 0) {
 					no_free_locations = false;
 				} else {
@@ -2983,6 +2995,7 @@ static void initial_placement_blocks(int * free_locations, enum e_pad_loc_type p
 
 static void initial_placement_location(int * free_locations, int itype,
 		int *pipos, int *px_to, int *py_to, int *pz_to) {
+
 	*pipos = vtr::irand(free_locations[itype] - 1);
 	*px_to = legal_pos[itype][*pipos].x;
 	*py_to = legal_pos[itype][*pipos].y;
@@ -3236,8 +3249,7 @@ static void check_place(const t_placer_costs& costs,
 				if (EMPTY_BLOCK_ID == bnum || INVALID_BLOCK_ID == bnum)
 					continue;
 
-				// Check if block has been placed in a valid location
-				if (!check_if_legal_placement(cluster_ctx.clb_nlist.block_type(bnum), device_ctx.grid[i][j].type)) {
+				if (!cluster_ctx.clb_nlist.block_type(bnum)->is_available_tile_index(device_ctx.grid[i][j].type->index)) {
 					VTR_LOG_ERROR(
 							"Block %zu type (%s) does not match grid location (%zu,%zu) type (%s).\n",
 							size_t(bnum), cluster_ctx.clb_nlist.block_type(bnum)->name, i, j, device_ctx.grid[i][j].type->name);
@@ -3376,22 +3388,3 @@ static void generate_post_place_timing_reports(const t_placer_opts& placer_opts,
 
     timing_reporter.report_timing_setup(placer_opts.post_place_timing_report_file, *timing_info.setup_analyzer(), analysis_opts.timing_report_npaths);
 }
-
-static std::vector<int> get_available_placement_itypes(t_type_ptr type) {
-	std::vector<int> itypes(1, type->index);
-
-	for(int itype = 0; itype < type->num_equivalent_tiles; itype++) {
-		itypes.push_back(type->equivalent_tiles[itype]->index);
-	}
-
-	return itypes;
-}
-
-static bool check_if_legal_placement(t_type_ptr cluster_type, t_type_ptr grid_type) {
-    std::vector<int> itypes = get_available_placement_itypes(cluster_type);
-	if (std::find(itypes.begin(), itypes.end(), grid_type->index) != itypes.end()) {
-		return true;
-	}
-
-	return false;
-}