mode selection: check modes while committing rt nets

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

Author: acomodi

vpr/src/pack/cluster_router.cpp

@@ -78,7 +78,9 @@ static void remove_pin_from_rt_terminals(t_lb_router_data *router_data, const At
 
 static void fix_duplicate_equivalent_pins(t_lb_router_data *router_data);
 
-static void commit_remove_rt(t_lb_trace *rt, t_lb_router_data *router_data, e_commit_remove op);
+static void commit_remove_rt(t_lb_trace *rt, t_lb_router_data *router_data, e_commit_remove op,
+		std::unordered_map<const t_pb_graph_node *, const t_mode *> *mode_map,
+		bool *is_mode_conflict);
 static bool is_skip_route_net(t_lb_trace *rt, t_lb_router_data *router_data);
 static void add_source_to_rt(t_lb_router_data *router_data, int inet);
 static void expand_rt(t_lb_router_data *router_data, int inet, reservable_pq<t_expansion_node, vector <t_expansion_node>, compare_expansion_node> &pq, int irt_net);
@@ -216,49 +218,6 @@ static bool check_edge_for_route_conflicts(
 	return false;
 }
 
-// Walk one net and either add the pb_type modes to mode_map, or if they already
-// exist, ensure that the edges in the net are not in conflict.
-static bool check_net_for_route_conflicts(
-		std::unordered_map<const t_pb_graph_node *, const t_mode *> *mode_map,
-		const t_lb_trace *driver, const t_lb_router_data *router_data) {
-	VTR_ASSERT(driver != nullptr);
-
-	vector <t_lb_type_rr_node> & lb_type_graph = *router_data->lb_type_graph;
-	auto &driver_node = lb_type_graph[driver->current_node];
-	auto *driver_pin = driver_node.pb_graph_pin;
-
-	// Check each driver_pin -> pin edge.
-	if(driver_pin != nullptr) {
-		for (const auto &next_node : driver->next_nodes) {
-			auto &node = lb_type_graph[next_node.current_node];
-			if(check_edge_for_route_conflicts(mode_map, driver_pin, node.pb_graph_pin)) {
-				return true;
-			}
-		}
-	}
-
-	// Walk the rest of the net.
-	for (const auto &next_node : driver->next_nodes) {
-		if (check_net_for_route_conflicts(mode_map, &next_node, router_data)) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
-// Walk nets and check if each pb_type has the same mode.
-static bool check_for_route_conflicts(const vector <t_intra_lb_net> &lb_nets, const t_lb_router_data *router_data) {
-	std::unordered_map<const t_pb_graph_node *, const t_mode *> mode_map;
-	for(const auto &net : lb_nets) {
-		if(check_net_for_route_conflicts(&mode_map, net.rt_tree, router_data)) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
 /*****************************************************************************************
 * Routing Functions
 ******************************************************************************************/
@@ -384,6 +343,8 @@ bool try_intra_lb_route(t_lb_router_data *router_data,
 		router_data->lb_rr_node_stats[inode].occ = 0;
 	}
 
+	std::unordered_map<const t_pb_graph_node *, const t_mode *> mode_map;
+
 	/*	Iteratively remove congestion until a successful route is found.
 		Cap the total number of iterations tried so that if a solution does not exist, then the router won't run indefinitely */
 	router_data->pres_con_fac = router_data->params.pres_fac;
@@ -395,7 +356,7 @@ bool try_intra_lb_route(t_lb_router_data *router_data,
 			if (is_skip_route_net(lb_nets[idx].rt_tree, router_data)) {
 				continue;
 			}
-			commit_remove_rt(lb_nets[idx].rt_tree, router_data, RT_REMOVE);
+			commit_remove_rt(lb_nets[idx].rt_tree, router_data, RT_REMOVE, &mode_map, is_mode_conflict);
 			free_lb_net_rt(lb_nets[idx].rt_tree);
 			lb_nets[idx].rt_tree = nullptr;
 			add_source_to_rt(router_data, idx);
@@ -478,17 +439,10 @@ bool try_intra_lb_route(t_lb_router_data *router_data,
 				}
 			}
 
-			commit_remove_rt(lb_nets[idx].rt_tree, router_data, RT_COMMIT);
-		}
-
-		if(!is_impossible) {
-			// We've checked that each net has no mode conflicts within the
-			// net via route_has_conflict, however this is in insufficient.
-			//
-			// All nets from each pb_type must not have a mode conflict between
-			// the nets.
-			is_impossible = check_for_route_conflicts(lb_nets, router_data);
-			*is_mode_conflict = is_impossible;
+			commit_remove_rt(lb_nets[idx].rt_tree, router_data, RT_COMMIT, &mode_map, is_mode_conflict);
+			if (*is_mode_conflict) {
+				is_impossible = true;
+			}
 		}
 
 		if(!is_impossible) {
@@ -979,7 +933,9 @@ static void fix_duplicate_equivalent_pins(t_lb_router_data *router_data) {
 }
 
 /* Commit or remove route tree from currently routed solution */
-static void commit_remove_rt(t_lb_trace *rt, t_lb_router_data *router_data, e_commit_remove op) {
+static void commit_remove_rt(t_lb_trace *rt, t_lb_router_data *router_data, e_commit_remove op,
+		std::unordered_map<const t_pb_graph_node *, const t_mode *> *mode_map,
+		bool *is_mode_conflict) {
 	t_lb_rr_node_stats *lb_rr_node_stats;
 	t_explored_node_tb *explored_node_tb;
 	vector <t_lb_type_rr_node> & lb_type_graph = *router_data->lb_type_graph;
@@ -995,6 +951,7 @@ static void commit_remove_rt(t_lb_trace *rt, t_lb_router_data *router_data, e_co
 
 	inode = rt->current_node;
 
+
 	/* Determine if node is being used or removed */
 	if (op == RT_COMMIT) {
 		incr = 1;
@@ -1009,9 +966,24 @@ static void commit_remove_rt(t_lb_trace *rt, t_lb_router_data *router_data, e_co
 	lb_rr_node_stats[inode].occ += incr;
 	VTR_ASSERT(lb_rr_node_stats[inode].occ >= 0);
 
+	auto &driver_node = lb_type_graph[inode];
+	auto *driver_pin = driver_node.pb_graph_pin;
+
 	/* Recursively update route tree */
 	for(unsigned int i = 0; i < rt->next_nodes.size(); i++) {
-		commit_remove_rt(&rt->next_nodes[i], router_data, op);
+		// Check to see if there is no mode conflict between previous nets.
+		// A conflict is present if there are differing modes between a pb_graph_node
+		// and its children.
+		if (op == RT_COMMIT) {
+			auto &node = lb_type_graph[rt->next_nodes[i].current_node];
+			auto *pin = node.pb_graph_pin;
+
+			if (check_edge_for_route_conflicts(mode_map, driver_pin, pin)) {
+				*is_mode_conflict = true;
+			}
+		}
+
+		commit_remove_rt(&rt->next_nodes[i], router_data, op, mode_map, is_mode_conflict);
 	}
 }