Merge branch 'master' of github.com:verilog-to-routing/vtr-verilog-to-routing

Author: jeanlego

vpr/src/base/SetupVPR.cpp

@@ -363,6 +363,7 @@ static void SetupRouterOpts(const t_options& Options, t_router_opts *RouterOpts)
     RouterOpts->router_debug_sink_rr = Options.router_debug_sink_rr;
     RouterOpts->lookahead_type = Options.router_lookahead_type;
     RouterOpts->max_convergence_count = Options.router_max_convergence_count;
+    RouterOpts->reconvergence_cpd_threshold = Options.router_reconvergence_cpd_threshold;
 }
 
 static void SetupAnnealSched(const t_options& Options,

vpr/src/base/read_options.cpp

@@ -1179,6 +1179,14 @@ static argparse::ArgumentParser create_arg_parser(std::string prog_name, t_optio
             .default_value("1")
             .show_in(argparse::ShowIn::HELP_ONLY);
 
+    route_timing_grp.add_argument(args.router_reconvergence_cpd_threshold, "--router_reconvergence_cpd_threshold")
+            .help("Specifies the minimum potential CPD improvement for which the router will"
+                  " continue to attempt re-convergent routing."
+                  " For example, a value of 0.99 means the router will not give up on reconvergent"
+                  " routing if it thinks a > 1% CPD reduction is possible.")
+            .default_value("0.99")
+            .show_in(argparse::ShowIn::HELP_ONLY);
+
     auto& analysis_grp = parser.add_argument_group("analysis options");
 
     analysis_grp.add_argument<bool,ParseOnOff>(args.full_stats, "--full_stats")

vpr/src/base/read_options.h

@@ -122,6 +122,7 @@ struct t_options {
     argparse::ArgValue<int> router_debug_sink_rr;
     argparse::ArgValue<e_router_lookahead> router_lookahead_type;
     argparse::ArgValue<int> router_max_convergence_count;
+    argparse::ArgValue<float> router_reconvergence_cpd_threshold;
 
     /* Analysis options */
     argparse::ArgValue<bool> full_stats;

vpr/src/base/vpr_types.h

@@ -961,6 +961,7 @@ struct t_router_opts {
     int router_debug_sink_rr;
     e_router_lookahead lookahead_type;
     int max_convergence_count;
+    float reconvergence_cpd_threshold;
 };
 
 struct t_analysis_opts {

vpr/src/route/route_timing.cpp

@@ -253,6 +253,11 @@ static bool is_better_quality_routing(const vtr::vector<ClusterNetId,t_traceback
                                    const WirelengthInfo& wirelength_info,
                                    std::shared_ptr<const SetupHoldTimingInfo> timing_info);
 
+static bool early_reconvergence_exit_heuristic(const t_router_opts& router_opts, 
+                                               int itry_since_last_convergence,
+                                               std::shared_ptr<const SetupHoldTimingInfo> timing_info,
+                                               const RoutingMetrics& best_routing_metrics);
+
 /************************ Subroutine definitions *****************************/
 bool try_timing_driven_route(t_router_opts router_opts,
         vtr::vector_map<ClusterNetId, float *> &net_delay,
@@ -357,6 +362,7 @@ bool try_timing_driven_route(t_router_opts router_opts,
     float prev_iter_cumm_time = 0;
     vtr::Timer iteration_timer;
     int num_net_bounding_boxes_updated = 0;
+    int itry_since_last_convergence = -1;
     for (itry = 1; itry <= router_opts.max_router_iterations; ++itry) {
 
         RouterStats router_iteration_stats;
@@ -381,6 +387,10 @@ bool try_timing_driven_route(t_router_opts router_opts,
             route_timing_info = make_constant_timing_info(0.);
         }
 
+        if (itry_since_last_convergence >= 0) {
+            ++itry_since_last_convergence;
+        }
+
         /*
          * Route each net
          */
@@ -499,20 +509,33 @@ bool try_timing_driven_route(t_router_opts router_opts,
             }
 
             //Decrease pres_fac so that criticl connections will take more direct routes
-            pres_fac = router_opts.initial_pres_fac;
+            //Note that we use first_iter_pres_fac here (typically zero), and switch to
+            //use initial_pres_fac on the next iteration.
+            pres_fac = router_opts.first_iter_pres_fac;
 
             //Reduce timing tolerances to re-route more delay-suboptimal signals
-            connections_inf.set_connection_criticality_tolerance(0.8);
+            connections_inf.set_connection_criticality_tolerance(0.7);
             connections_inf.set_connection_delay_tolerance(1.01);
 
             ++legal_convergence_count;
+            itry_since_last_convergence = 0;
 
             VTR_ASSERT(routing_is_successful);
         }
 
-        //Have we converged the maximum number of times, or did not make any changes?
+        if (itry_since_last_convergence == 1) {
+            //We used first_iter_pres_fac when we started routing again
+            //after the first routing convergence. Since that is often zero,
+            //we want to set pres_fac to a reasonable (i.e. typically non-zero)
+            //value afterwards -- so it grows when multiplied by pres_fac_mult
+            pres_fac = router_opts.initial_pres_fac;
+        }
+
+        //Have we converged the maximum number of times, did not make any changes, or does it seem
+        //unlikely additional convergences will improve QoR?
         if (legal_convergence_count >= router_opts.max_convergence_count
-            || router_iteration_stats.connections_routed == 0) {
+            || router_iteration_stats.connections_routed == 0
+            || early_reconvergence_exit_heuristic(router_opts, itry_since_last_convergence, timing_info, best_routing_metrics)) {
             break; //Done routing
         }
 
@@ -526,7 +549,7 @@ bool try_timing_driven_route(t_router_opts router_opts,
 
         //Estimate at what iteration we will converge to a legal routing
         if (overuse_info.overused_nodes() > ROUTING_PREDICTOR_MIN_ABSOLUTE_OVERUSE_THRESHOLD) {
-            //Only abort if we have a significant number of overused resources
+            //Only consider aborting if we have a significant number of overused resources
 
             if (!std::isnan(est_success_iteration) && est_success_iteration > abort_iteration_threshold) {
                 VTR_LOG("Routing aborted, the predicted iteration for a successful route (%.1f) is too high.\n", est_success_iteration);
@@ -2516,3 +2539,26 @@ static bool is_better_quality_routing(const vtr::vector<ClusterNetId,t_traceback
     //Finally, wirelength tie breaker
     return wirelength_info.used_wirelength() < best_routing_metrics.used_wirelength;
 }
+
+static bool early_reconvergence_exit_heuristic(const t_router_opts& router_opts,
+                                               int itry_since_last_convergence,
+                                               std::shared_ptr<const SetupHoldTimingInfo> timing_info,
+                                               const RoutingMetrics& best_routing_metrics) {
+    //Give-up on reconvergent routing if the CPD improvement after the 
+    //first iteration since convergence is small, compared to the best 
+    //CPD seen so far
+    if (itry_since_last_convergence == 1) {
+        float cpd_ratio = timing_info->setup_worst_negative_slack() / best_routing_metrics.sWNS;
+
+        //Give up if we see less than a 1% CPD improvement,
+        //after reducing pres_fac. Typically larger initial 
+        //improvements are needed to see an actual improvement 
+        //in final legal routing quality.
+        if (cpd_ratio >= router_opts.reconvergence_cpd_threshold) {
+            VTR_LOG("Giving up routing since additional routing convergences seem unlikely to improve quality (CPD ratio: %g)\n", cpd_ratio);
+            return true; //Potential CPD improvement is small, don't spend run-time trying to improve it
+        }
+    }
+
+    return false; //Don't give up
+}

vtr_flow/scripts/run_vtr_flow.pl

@@ -119,6 +119,7 @@
 my $odin_adder_config_path = "default";
 my $use_odin_xml_config = 1;
 my $relax_W_factor = 1.3;
+my $crit_path_router_iterations = undef;
 
 
 ##########
@@ -206,6 +207,9 @@
 	elsif ( $token eq "-relax_W_factor" ){
 		$relax_W_factor = shift(@ARGV);
 	}
+	elsif ( $token eq "-crit_path_router_iterations" ){
+		$crit_path_router_iterations = shift(@ARGV);
+	}
     # else forward the argument
 	else {
         push @forwarded_vpr_args, $token;
@@ -873,6 +877,10 @@
                     push(@relaxed_W_extra_vpr_args, ("--route"));
                     push(@relaxed_W_extra_vpr_args, ("--route_chan_width", "$relaxed_W"));
 
+                    if (defined $crit_path_router_iterations) {
+                        push(@relaxed_W_extra_vpr_args, ("--max_router_iterations", "$crit_path_router_iterations"));
+                    }
+
                     my $relaxed_W_log_file = "vpr.crit_path.out";
                     $q = run_vpr({
                             arch_name => $architecture_file_name,