add --quick_check_route, disables slow non-configurable edge check

Signed-off-by: Dustin DeWeese <[email protected]>

Author: HackerFoo

vpr/src/base/SetupVPR.cpp

@@ -376,6 +376,7 @@ static void SetupRouterOpts(const t_options& Options, t_router_opts* RouterOpts)
     RouterOpts->write_router_lookahead = Options.write_router_lookahead;
     RouterOpts->read_router_lookahead = Options.read_router_lookahead;
     RouterOpts->disable_check_route = Options.disable_check_route;
+    RouterOpts->quick_check_route = Options.quick_check_route;
 }
 
 static void SetupAnnealSched(const t_options& Options,

vpr/src/base/read_options.cpp

@@ -1625,6 +1625,11 @@ argparse::ArgumentParser create_arg_parser(std::string prog_name, t_options& arg
         .default_value("off")
         .show_in(argparse::ShowIn::HELP_ONLY);
 
+    route_timing_grp.add_argument<bool, ParseOnOff>(args.quick_check_route, "--quick_check_route")
+        .help("Runs check_route, disabling slow checks, once routing step has finished or when routing file is loaded")
+        .default_value("off")
+        .show_in(argparse::ShowIn::HELP_ONLY);
+
     route_timing_grp.add_argument(args.router_debug_net, "--router_debug_net")
         .help(
             "Controls when router debugging is enabled.\n"

vpr/src/base/read_options.h

@@ -134,6 +134,7 @@ struct t_options {
     argparse::ArgValue<e_router_algorithm> RouterAlgorithm;
     argparse::ArgValue<int> min_incremental_reroute_fanout;
     argparse::ArgValue<bool> disable_check_route;
+    argparse::ArgValue<bool> quick_check_route;
 
     /* Timing-driven router options only */
     argparse::ArgValue<float> astar_fac;

vpr/src/base/vpr_api.cpp

@@ -689,7 +689,7 @@ RouteStatus vpr_route_flow(t_vpr_setup& vpr_setup, const t_arch& arch) {
         if (route_status.success()) {
             //Sanity check the routing
             if (!router_opts.disable_check_route) {
-                check_route(router_opts.route_type);
+                check_route(router_opts.route_type, router_opts.quick_check_route);
             }
             get_serial_num();
 

vpr/src/base/vpr_types.h

@@ -950,6 +950,7 @@ struct t_router_opts {
     std::string write_router_lookahead;
     std::string read_router_lookahead;
     bool disable_check_route;
+    bool quick_check_route;
 };
 
 struct t_analysis_opts {

vpr/src/route/check_route.cpp

@@ -27,12 +27,13 @@ static void reset_flags(ClusterNetId inet, bool* connected_to_route);
 static void check_locally_used_clb_opins(const t_clb_opins_used& clb_opins_used_locally,
                                          enum e_route_type route_type);
 
+static void check_all_non_configurable_edges();
 static bool check_non_configurable_edges(ClusterNetId net, const t_non_configurable_rr_sets& non_configurable_rr_sets);
 static void check_net_for_stubs(ClusterNetId net);
 
 /************************ Subroutine definitions ****************************/
 
-void check_route(enum e_route_type route_type) {
+void check_route(enum e_route_type route_type, bool quick) {
     /* This routine checks that a routing:  (1) Describes a properly         *
      * connected path for each net, (2) this path connects all the           *
      * pins spanned by that net, and (3) that no routing resources are       *
@@ -68,8 +69,6 @@ void check_route(enum e_route_type route_type) {
 
     check_locally_used_clb_opins(route_ctx.clb_opins_used_locally, route_type);
 
-    auto non_configurable_rr_sets = identify_non_configurable_rr_sets();
-
     connected_to_route = (bool*)vtr::calloc(device_ctx.rr_nodes.size(), sizeof(bool));
 
     max_pins = 0;
@@ -156,8 +155,6 @@ void check_route(enum e_route_type route_type) {
             }
         }
 
-        check_non_configurable_edges(net_id, non_configurable_rr_sets);
-
         check_net_for_stubs(net_id);
 
         reset_flags(net_id, connected_to_route);
@@ -166,6 +163,11 @@ void check_route(enum e_route_type route_type) {
 
     free(pin_done);
     free(connected_to_route);
+
+    if (!quick) {
+        check_all_non_configurable_edges();
+    }
+
     VTR_LOG("Completed routing consistency check successfully.\n");
     VTR_LOG("\n");
 }
@@ -625,6 +627,23 @@ static void check_node_and_range(int inode, enum e_route_type route_type) {
     check_rr_node(inode, route_type, device_ctx);
 }
 
+//Checks that all non-configurable edges are in a legal configuration
+//This check is slow, so it has been moved out of check_route()
+static void check_all_non_configurable_edges() {
+    VTR_LOG("\n");
+    VTR_LOG("Checking to ensure non-configurable edges are legal...\n");
+
+    auto non_configurable_rr_sets = identify_non_configurable_rr_sets();
+
+    auto& cluster_ctx = g_vpr_ctx.clustering();
+    for (auto net_id : cluster_ctx.clb_nlist.nets()) {
+        check_non_configurable_edges(net_id, non_configurable_rr_sets);
+    }
+
+    VTR_LOG("Completed non-configurable edge check successfully.\n");
+    VTR_LOG("\n");
+}
+
 //Checks that the specified routing is legal with respect to non-configurable edges
 //
 //For routing to be legal if *any* non-configurable edge is used, so must *all*

vpr/src/route/check_route.h

@@ -3,7 +3,7 @@
 #include "physical_types.h"
 #include "route_common.h"
 
-void check_route(enum e_route_type route_type);
+void check_route(enum e_route_type route_type, bool quick);
 
 void recompute_occupancy_from_scratch();