Merge remote-tracking branch 'origin/master' into feature-ap-iterative-repacking

Author: AlexandreSinger

doc/src/vpr/command_line_usage.rst

@@ -256,6 +256,16 @@ General Options
 
     **Default:** ``on``
 
+.. option:: --verify_route_file_switch_id {on | off}
+
+    Verify that the switch IDs in the routing file are consistent with those in the RR Graph.
+    Set this to false when switch IDs in the routing file may differ from the RR Graph.
+    For example, when analyzing different timing corners using the same netlist, placement, and routing files,
+    the RR switch IDs in the RR Graph may differ due to changes in delays.
+    In such cases, set this option to false so that the switch IDs from the RR Graph are used, and those in the routing file are ignored.
+
+    **Default:** ``on``
+
 .. option:: --target_utilization <float>
 
     Sets the target device utilization.

libs/EXTERNAL/libcatch2

@@ -517,6 +517,8 @@ static void SetupRouterOpts(const t_options& Options, t_router_opts* RouterOpts)
     RouterOpts->custom_3d_sb_fanin_fanout = Options.custom_3d_sb_fanin_fanout;
     RouterOpts->with_timing_analysis = Options.timing_analysis;
 
+    RouterOpts->verify_route_file_switch_id = Options.verify_route_file_switch_id;
+
     RouterOpts->generate_router_lookahead_report = Options.generate_router_lookahead_report.value();
 }
 

libs/EXTERNAL/libezgl

@@ -1551,7 +1551,7 @@ class NetlistWriterVisitor : public NetlistVisitor {
 
                 if (port_class == "clock") {
                     VTR_ASSERT(pb_graph_node->num_clock_pins[iport] == 1); //Expect a single clock pin
-                    input_port_conns["clock"].push_back(net);
+                    input_port_conns[port->name].push_back(net);
                 } else {
                     VPR_FATAL_ERROR(VPR_ERROR_IMPL_NETLIST_WRITER,
                                     "Unrecognized input port class '%s' for primitive '%s' (%s)\n", port_class.c_str(), atom->name, pb_type->name);

vpr/src/base/SetupVPR.cpp

@@ -6,9 +6,9 @@
 #include "route_common.h"
 
 #include <vector>
+#include <stack>
 
 std::pair<t_trace*, t_trace*> traceback_from_route_tree_recurr(t_trace* head, t_trace* tail, const RouteTreeNode& node);
-bool validate_traceback_recurr(t_trace* trace, std::set<int>& seen_rr_nodes);
 void free_trace_data(t_trace* tptr);
 
 /** Build a route tree from a traceback */
@@ -109,7 +109,7 @@ t_trace* TracebackCompat::traceback_from_route_tree(const RouteTree& tree) {
 
     std::tie(head, tail) = traceback_from_route_tree_recurr(nullptr, nullptr, tree.root());
 
-    VTR_ASSERT(validate_traceback(head));
+    VTR_ASSERT(validate_and_update_traceback(head));
 
     return head;
 }
@@ -141,70 +141,65 @@ void print_traceback(const t_trace* trace) {
     VTR_LOG("\n");
 }
 
-bool validate_traceback(t_trace* trace) {
-    std::set<int> seen_rr_nodes;
-
-    return validate_traceback_recurr(trace, seen_rr_nodes);
-}
-
-bool validate_traceback_recurr(t_trace* trace, std::set<int>& seen_rr_nodes) {
+bool validate_and_update_traceback(t_trace* trace, bool verify_switch_id /* = true */) {
     if (!trace) {
         return true;
     }
 
-    seen_rr_nodes.insert(trace->index);
+    std::set<int> seen_rr_nodes;
+    std::stack<t_trace*> trace_stack;
+    trace_stack.push(trace);
 
-    t_trace* next = trace->next;
+    while (!trace_stack.empty()) {
+        trace = trace_stack.top();
+        trace_stack.pop();
+        seen_rr_nodes.insert(trace->index);
+        t_trace* next = trace->next;
 
-    if (next) {
-        if (trace->iswitch == OPEN) { //End of a branch
+        if (next == nullptr) {
+            continue;
+        }
 
-            //Verify that the next element (branch point) has been already seen in the traceback so far
+        if (trace->iswitch == OPEN) { // End of a branch
+            // Verify that the next element (branch point) has been already seen in the traceback so far
             if (!seen_rr_nodes.count(next->index)) {
                 VPR_FATAL_ERROR(VPR_ERROR_ROUTE, "Traceback branch point %d not found", next->index);
-            } else {
-                //Recurse along the new branch
-                return validate_traceback_recurr(next, seen_rr_nodes);
             }
-        } else { //Midway along branch
-
-            //Check there is an edge connecting trace and next
-
-            auto& device_ctx = g_vpr_ctx.device();
-            const auto& rr_graph = device_ctx.rr_graph;
+        } else { // Midway along branch
+            // Check there is an edge connecting trace and next
+            const auto& rr_graph = g_vpr_ctx.device().rr_graph;
             bool found = false;
             for (t_edge_size iedge = 0; iedge < rr_graph.num_edges(RRNodeId(trace->index)); ++iedge) {
                 int to_node = size_t(rr_graph.edge_sink_node(RRNodeId(trace->index), iedge));
-
                 if (to_node == next->index) {
                     found = true;
-
-                    //Verify that the switch matches
                     int rr_iswitch = rr_graph.edge_switch(RRNodeId(trace->index), iedge);
-                    if (trace->iswitch != rr_iswitch) {
-                        VPR_FATAL_ERROR(VPR_ERROR_ROUTE, "Traceback mismatched switch type: traceback %d rr_graph %d (RR nodes %d -> %d)\n",
-                                        trace->iswitch, rr_iswitch,
-                                        trace->index, to_node);
+                    if (verify_switch_id) {
+                        // Verify that the switch matches
+                        if (trace->iswitch != rr_iswitch) {
+                            VPR_FATAL_ERROR(VPR_ERROR_ROUTE, "Traceback mismatched switch type: traceback %d rr_graph %d (RR nodes %d -> %d)\n",
+                                            trace->iswitch, rr_iswitch,
+                                            trace->index, to_node);
+                        }
+                    } else {
+                        // Update the switch ID in the traceback to match the RR Graph
+                        trace->iswitch = rr_iswitch;
                     }
                     break;
                 }
             }
-
             if (!found) {
                 VPR_FATAL_ERROR(VPR_ERROR_ROUTE, "Traceback no RR edge between RR nodes %d -> %d\n", trace->index, next->index);
             }
-
-            //Recurse
-            return validate_traceback_recurr(next, seen_rr_nodes);
         }
+        // Recurse
+        trace_stack.push(next);
     }
 
-    VTR_ASSERT(!next);
-    return true; //End of traceback
+    return true;
 }
 
-t_trace*
-alloc_trace_data() {
+t_trace* alloc_trace_data() {
     return (t_trace*)malloc(sizeof(t_trace));
 }
 

vpr/src/base/netlist_writer.cpp

@@ -46,4 +46,17 @@ class TracebackCompat {
 t_trace* alloc_trace_data();
 void free_traceback(t_trace* trace);
 void print_traceback(const t_trace* trace);
-bool validate_traceback(t_trace* trace);
+
+/**
+ * @brief Validate the integrity of the traceback rooted a trace: it should contain only valid rr nodes, branches in the routing tree
+ *        should link to existing routing, and edges in the traceback should exist in the RRGraph.
+ *        If verify_switch_id is true, this routine also checks that the switch types used in the traceback match those in the
+ *        RRGraph. If verify_switch_id is false, the switch ids (types) are remapped to those in the RRGraph. This switch remapping is
+ *        useful when an RRGraph with a more detailed delay model (and hence more switch types) is used with a prior routing.
+ * 
+ * @param trace Pointer to the head of the routing trace of the net to validate and update.
+ * @param verify_switch_id Whether to verify the switch IDs in the traceback.
+ * 
+ * @return true if the traceback is valid, false otherwise.
+ */
+bool validate_and_update_traceback(t_trace* trace, bool verify_switch_id = true);

vpr/src/base/old_traceback.cpp

@@ -1637,6 +1637,16 @@ argparse::ArgumentParser create_arg_parser(const std::string& prog_name, t_optio
         .default_value("on")
         .show_in(argparse::ShowIn::HELP_ONLY);
 
+    gen_grp.add_argument<bool, ParseOnOff>(args.verify_route_file_switch_id, "--verify_route_file_switch_id")
+        .help(
+            "Verify that the switch IDs in the routing file are consistent with those in the RR Graph. "
+            "Set this to false when switch IDs in the routing file may differ from the RR Graph. "
+            "For example, when analyzing different timing corners using the same netlist, placement, and routing files, "
+            "the RR switch IDs in the RR Graph may differ due to changes in delays. "
+            "In such cases, set this option to false so that the switch IDs from the RR Graph are used, and those in the routing file are ignored.\n")
+        .default_value("on")
+        .show_in(argparse::ShowIn::HELP_ONLY);
+
     gen_grp.add_argument(args.target_device_utilization, "--target_utilization")
         .help(
             "Sets the target device utilization."

vpr/src/base/old_traceback.h

@@ -73,6 +73,7 @@ struct t_options {
     argparse::ArgValue<e_timing_update_type> timing_update_type;
     argparse::ArgValue<bool> CreateEchoFile;
     argparse::ArgValue<bool> verify_file_digests;
+    argparse::ArgValue<bool> verify_route_file_switch_id;
     argparse::ArgValue<std::string> device_layout;
     argparse::ArgValue<float> target_device_utilization;
     argparse::ArgValue<e_constant_net_method> constant_net_method;