Disable high fanout routing when progress slows

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

Author: HackerFoo

vpr/src/route/route_timing.cpp

@@ -82,7 +82,8 @@ static bool timing_driven_route_sink(
     t_rt_node* rt_root,
     t_rt_node** rt_node_of_sink,
     SpatialRouteTreeLookup& spatial_rt_lookup,
-    RouterStats& router_stats);
+    RouterStats& router_stats,
+    const RoutingPredictor& routing_predictor);
 
 template<typename ConnectionRouter>
 static bool timing_driven_pre_route_to_clock_root(
@@ -414,7 +415,8 @@ bool try_timing_driven_route_tmpl(const t_router_opts& router_opts,
                                                            route_timing_info,
                                                            pin_timing_invalidator.get(),
                                                            budgeting_inf,
-                                                           was_rerouted);
+                                                           was_rerouted,
+                                                           routing_predictor);
             if (!is_routable) {
                 return (false); //Impossible to route
             }
@@ -756,7 +758,8 @@ bool try_timing_driven_route_net(ConnectionRouter& router,
                                  std::shared_ptr<SetupTimingInfo> timing_info,
                                  ClusteredPinTimingInvalidator* pin_timing_invalidator,
                                  route_budgets& budgeting_inf,
-                                 bool& was_rerouted) {
+                                 bool& was_rerouted,
+                                 const RoutingPredictor& routing_predictor) {
     auto& cluster_ctx = g_vpr_ctx.clustering();
     auto& route_ctx = g_vpr_ctx.mutable_routing();
 
@@ -787,7 +790,8 @@ bool try_timing_driven_route_net(ConnectionRouter& router,
                                             netlist_pin_lookup,
                                             timing_info,
                                             pin_timing_invalidator,
-                                            budgeting_inf);
+                                            budgeting_inf,
+                                            routing_predictor);
 
         profiling::net_fanout_end(cluster_ctx.clb_nlist.net_sinks(net_id).size());
 
@@ -911,7 +915,8 @@ bool timing_driven_route_net(ConnectionRouter& router,
                              const ClusteredPinAtomPinsLookup& netlist_pin_lookup,
                              std::shared_ptr<SetupTimingInfo> timing_info,
                              ClusteredPinTimingInvalidator* pin_timing_invalidator,
-                             route_budgets& budgeting_inf) {
+                             route_budgets& budgeting_inf,
+                             const RoutingPredictor& routing_predictor) {
     /* Returns true as long as found some way to hook up this net, even if that *
      * way resulted in overuse of resources (congestion).  If there is no way   *
      * to route this net, even ignoring congestion, it returns false.  In this  *
@@ -1047,7 +1052,8 @@ bool timing_driven_route_net(ConnectionRouter& router,
                                       router_opts.high_fanout_threshold,
                                       rt_root, rt_node_of_sink,
                                       spatial_route_tree_lookup,
-                                      router_stats))
+                                      router_stats,
+                                      routing_predictor))
             return false;
 
         profiling::conn_finish(route_ctx.net_rr_terminals[net_id][0],
@@ -1187,7 +1193,8 @@ static bool timing_driven_route_sink(
     t_rt_node* rt_root,
     t_rt_node** rt_node_of_sink,
     SpatialRouteTreeLookup& spatial_rt_lookup,
-    RouterStats& router_stats) {
+    RouterStats& router_stats,
+    const RoutingPredictor& routing_predictor) {
     /* Build a path from the existing route tree rooted at rt_root to the target_node
      * add this branch to the existing route tree and update pathfinder costs and rr_node_route_inf to reflect this */
     auto& route_ctx = g_vpr_ctx.mutable_routing();
@@ -1216,7 +1223,7 @@ static bool timing_driven_route_sink(
     //We normally route high fanout nets by only adding spatially close-by routing to the heap (reduces run-time).
     //However, if the current sink is 'critical' from a timing perspective, we put the entire route tree back onto
     //the heap to ensure it has more flexibility to find the best path.
-    if (high_fanout && !sink_critical && !net_is_global && !net_is_clock) {
+    if (high_fanout && !sink_critical && !net_is_global && !net_is_clock && !(routing_predictor.get_slope() > -0.5)) {
         std::tie(found_path, cheapest) = router.timing_driven_route_connection_from_route_tree_high_fanout(rt_root,
                                                                                                            sink_node,
                                                                                                            cost_params,

vpr/src/route/route_timing.h

@@ -12,6 +12,7 @@
 #include "spatial_route_tree_lookup.h"
 #include "connection_router_interface.h"
 #include "heap_type.h"
+#include "routing_predictor.h"
 
 int get_max_pins_per_net();
 
@@ -39,7 +40,8 @@ bool try_timing_driven_route_net(ConnectionRouter& router,
                                  std::shared_ptr<SetupTimingInfo> timing_info,
                                  ClusteredPinTimingInvalidator* pin_timing_invalidator,
                                  route_budgets& budgeting_inf,
-                                 bool& was_rerouted);
+                                 bool& was_rerouted,
+                                 const RoutingPredictor& routing_predictor);
 
 template<typename ConnectionRouter>
 bool timing_driven_route_net(ConnectionRouter& router,
@@ -55,7 +57,8 @@ bool timing_driven_route_net(ConnectionRouter& router,
                              const ClusteredPinAtomPinsLookup& netlist_pin_lookup,
                              std::shared_ptr<SetupTimingInfo> timing_info,
                              ClusteredPinTimingInvalidator* pin_timing_invalidator,
-                             route_budgets& budgeting_inf);
+                             route_budgets& budgeting_inf,
+                             const RoutingPredictor& routing_predictor);
 
 void alloc_timing_driven_route_structs(float** pin_criticality_ptr,
                                        int** sink_order_ptr,

vpr/src/route/routing_predictor.cpp

@@ -63,12 +63,9 @@ float covariance(std::vector<size_t> x_values, std::vector<float> y_values, floa
     return cov;
 }
 
-float RoutingPredictor::get_slope() {
-    if (iterations_.size() > min_history_) {
-        auto model = fit_model(iterations_, iteration_overused_rr_node_counts_, history_factor_);
-        return model.get_slope();
-    }
-    return -1;
+float RoutingPredictor::get_slope() const {
+    //Return cached slope, computed in add_iteration_overuse()
+    return slope_;
 }
 
 LinearModel simple_linear_regression(std::vector<size_t> x_values, std::vector<float> y_values) {
@@ -155,7 +152,8 @@ LinearModel fit_model(std::vector<size_t> iterations, std::vector<size_t> overus
 
 RoutingPredictor::RoutingPredictor(size_t min_history, float history_factor)
     : min_history_(min_history)
-    , history_factor_(history_factor) {
+    , history_factor_(history_factor)
+    , slope_(-1) {
     //nop
 }
 
@@ -204,4 +202,10 @@ float RoutingPredictor::estimate_overuse_slope() {
 void RoutingPredictor::add_iteration_overuse(size_t iteration, size_t overused_rr_node_count) {
     iterations_.push_back(iteration);
     iteration_overused_rr_node_counts_.push_back(overused_rr_node_count);
+
+    //Update slope
+    if (iterations_.size() > min_history_) {
+        auto model = fit_model(iterations_, iteration_overused_rr_node_counts_, history_factor_);
+        slope_ = model.get_slope();
+    }
 }

vpr/src/route/routing_predictor.h

@@ -25,14 +25,15 @@ class RoutingPredictor {
 
     void add_iteration_overuse(size_t iteration, size_t overused_rr_node_count);
 
-    float get_slope();
+    float get_slope() const;
 
   private:
     size_t min_history_;
     float history_factor_;
 
     std::vector<size_t> iterations_;
     std::vector<size_t> iteration_overused_rr_node_counts_;
+    float slope_;
 };
 
 #endif