Merge pull request verilog-to-routing#6 from litghost/cluster_fix

Add check to ensure that clustering uses consistent modes.

Author: litghost

vpr/src/pack/cluster_router.cpp

@@ -31,6 +31,7 @@ using namespace std;
 #include "atom_netlist.h"
 #include "vpr_utils.h"
 #include "pack_types.h"
+#include "pb_type_graph.h"
 #include "lb_type_rr_graph.h"
 #include "cluster_router.h"
 
@@ -154,7 +155,8 @@ static bool route_has_conflict(t_lb_trace *rt, t_lb_router_data *router_data) {
 
 	int cur_mode = -1;
 	for (unsigned int i = 0; i < rt->next_nodes.size(); i++) {
-		int new_mode = get_lb_type_rr_graph_edge_mode(lb_type_graph, rt->current_node, rt->next_nodes[i].current_node);
+		int new_mode = get_lb_type_rr_graph_edge_mode(lb_type_graph,
+            rt->current_node, rt->next_nodes[i].current_node);
 		if (cur_mode != -1 && cur_mode != new_mode) {
 			return true;
 		}
@@ -167,6 +169,86 @@ static bool route_has_conflict(t_lb_trace *rt, t_lb_router_data *router_data) {
 	return false;
 }
 
+// Check one edge for mode conflict.
+static bool check_edge_for_route_conflicts(
+		std::unordered_map<const t_pb_graph_node *, const t_mode *> *mode_map,
+		const t_pb_graph_pin *driver_pin, const t_pb_graph_pin *pin) {
+	if(driver_pin == nullptr) {
+		return false;
+	}
+
+	// Only check pins that are OUT_PORTs.
+	if(pin == nullptr || pin->port == nullptr || pin->port->type != OUT_PORT) {
+		return false;
+	}
+	VTR_ASSERT(!pin->port->is_clock);
+
+	auto *pb_graph_node = pin->parent_node;
+	VTR_ASSERT(pb_graph_node->pb_type == pin->port->parent_pb_type);
+
+	const t_pb_graph_edge *edge = get_edge_between_pins(driver_pin, pin);
+	VTR_ASSERT(edge != nullptr);
+
+	auto mode_of_edge = edge->interconnect->parent_mode_index;
+	auto *mode = &pb_graph_node->pb_type->modes[mode_of_edge];
+
+	auto result = mode_map->insert(std::make_pair(
+				pb_graph_node, mode));
+	if(!result.second) {
+		if(result.first->second != mode) {
+			std::cout << vtr::string_fmt(
+				"Differing modes for block.  Got %s previously and %s for interconnect %s.",
+				mode->name, result.first->second->name,
+				edge->interconnect->name) << std::endl;
+			return true;
+		}
+	}
+
+	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
@@ -389,6 +471,16 @@ 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 == false) {
+			// 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);
+		}
+
 		if(is_impossible == false) {
 			is_routed = is_route_success(router_data);
 		} else {

vpr/src/pack/output_clustering.cpp

@@ -23,6 +23,7 @@ using namespace std;
 #include "atom_netlist.h"
 #include "pack_types.h"
 #include "cluster_router.h"
+#include "pb_type_graph.h"
 #include "output_clustering.h"
 #include "read_xml_arch_file.h"
 #include "vpr_utils.h"
@@ -209,22 +210,20 @@ static void clustering_xml_open_block(pugi::xml_node parent_node, t_type_ptr typ
 			if (pb_type->ports[i].type == OUT_PORT) {
 				VTR_ASSERT(!pb_type->ports[i].is_clock);
 				for (j = 0; j < pb_type->ports[i].num_pins; j++) {
-					node_index = pb_graph_node->output_pins[port_index][j].pin_count_in_cluster;
+					const t_pb_graph_pin * pin  = &pb_graph_node->output_pins[port_index][j];
+					node_index = pin->pin_count_in_cluster;
 					if (pb_type->num_modes > 0 && pb_route[node_index].atom_net_id) {
 						prev_node = pb_route[node_index].driver_pb_pin_id;
-						t_pb_graph_pin *prev_pin = pb_graph_pin_lookup_from_index_by_type[type->index][prev_node];
-						for(prev_edge = 0; prev_edge < prev_pin->num_output_edges; prev_edge++) {
-							VTR_ASSERT(prev_pin->output_edges[prev_edge]->num_output_pins == 1);
-							if(prev_pin->output_edges[prev_edge]->output_pins[0]->pin_count_in_cluster == node_index) {
-								break;
-							}
-						}
-						VTR_ASSERT(prev_edge < prev_pin->num_output_edges);
-						mode_of_edge = prev_pin->output_edges[prev_edge]->interconnect->parent_mode_index;
+						const t_pb_graph_pin *prev_pin = pb_graph_pin_lookup_from_index_by_type[type->index][prev_node];
+						const t_pb_graph_edge *edge = get_edge_between_pins(prev_pin, pin);
+
+						mode_of_edge = edge->interconnect->parent_mode_index;
 						if(mode != nullptr && &pb_type->modes[mode_of_edge] != mode) {
 							vpr_throw(VPR_ERROR_PACK, __FILE__, __LINE__,
-									  "Differing modes for block.  Got %s previously and %s for edge %d.",
-									  mode->name, pb_type->modes[mode_of_edge].name, port_index);
+								"Differing modes for block.  Got %s previously and %s for edge %d (interconnect %s).",
+								mode->name, pb_type->modes[mode_of_edge].name,
+								port_index,
+								prev_pin->output_edges[prev_edge]->interconnect->name);
 						}
 						VTR_ASSERT(mode == nullptr || &pb_type->modes[mode_of_edge] == mode);
 						mode = &pb_type->modes[mode_of_edge];
@@ -313,8 +312,7 @@ static void clustering_xml_open_block(pugi::xml_node parent_node, t_type_ptr typ
 					is_used = false;
 					for (k = 0; k < child_pb_type->num_ports && !is_used; k++) {
 						if (child_pb_type->ports[k].type == OUT_PORT) {
-							for (m = 0; m < child_pb_type->ports[k].num_pins;
-									m++) {
+							for (m = 0; m < child_pb_type->ports[k].num_pins; m++) {
 								node_index =
 										pb_graph_node->child_pb_graph_nodes[mode_of_edge][i][j].output_pins[port_index][m].pin_count_in_cluster;
 								if (pb_route[node_index].atom_net_id) {

vpr/src/pack/pb_type_graph.cpp

@@ -1784,3 +1784,20 @@ static bool check_input_pins_equivalence(const t_pb_graph_pin* cur_pin,
 	return pins_equivalent;
 }
 
+const t_pb_graph_edge *get_edge_between_pins(const t_pb_graph_pin *driver_pin, const t_pb_graph_pin *pin) {
+	if(driver_pin == nullptr || pin == nullptr) {
+		return nullptr;
+	}
+
+	auto node_index = pin->pin_count_in_cluster;
+	for(int iedge = 0; iedge < driver_pin->num_output_edges; iedge++) {
+		auto *edge = driver_pin->output_edges[iedge];
+		VTR_ASSERT(edge->num_output_pins == 1);
+
+		if(edge->output_pins[0]->pin_count_in_cluster == node_index) {
+			return edge;
+		}
+	}
+	
+	return nullptr;
+}

vpr/src/pack/pb_type_graph.h

@@ -9,6 +9,13 @@ struct t_pb_graph_edge_comparator{
 	t_pb_graph_edge* parent_edge;
 };
 
+// Find the edge between driver_pin and pin.
+//
+// Returns nullptr on invalid input or error.
+const t_pb_graph_edge *get_edge_between_pins(
+		const t_pb_graph_pin *driver_pin,
+		const t_pb_graph_pin *pin);
+
 void alloc_and_load_all_pb_graphs(bool load_power_structures);
 void echo_pb_graph(char * filename);
 void free_pb_graph_edges();