fix compile errors after rebase

Author: duck2

utils/fasm/test/wire.net.post_routing

@@ -347,7 +347,7 @@ int main(int argc, const char **argv) {
                          vpr_setup.Segments,
                          is_flat);
         }
-        free_routing_structs(net_list);
+        free_routing_structs();
 
         /* free data structures */
         vpr_free_all(net_list, Arch, vpr_setup);

utils/route_diag/src/main.cpp

@@ -223,8 +223,7 @@ int binary_search_place_and_route(const Netlist<>& placement_net_list,
             }
 
             /* Save routing in case it is best. */
-            save_routing(router_net_list,
-                         best_routing,
+            save_routing(best_routing,
                          route_ctx.clb_opins_used_locally,
                          saved_clb_opins_used_locally);
 
@@ -348,8 +347,7 @@ int binary_search_place_and_route(const Netlist<>& placement_net_list,
 
             if (success && Fc_clipped == false) {
                 final = current;
-                save_routing(router_net_list,
-                             best_routing,
+                save_routing(best_routing,
                              route_ctx.clb_opins_used_locally,
                              saved_clb_opins_used_locally);
 
@@ -398,8 +396,7 @@ int binary_search_place_and_route(const Netlist<>& placement_net_list,
                        router_opts.has_choking_spot,
                        is_flat);
 
-    restore_routing(router_net_list,
-                    best_routing,
+    restore_routing(best_routing,
                     route_ctx.clb_opins_used_locally,
                     saved_clb_opins_used_locally);
 

vpr/src/base/place_and_route.cpp

@@ -210,7 +210,7 @@ std::unique_ptr<PlaceDelayModel> compute_place_delay_model(const t_placer_opts&
     }
 
     /*free all data structures that are no longer needed */
-    free_routing_structs(net_list);
+    free_routing_structs();
 
     return place_delay_model;
 }

vpr/src/place/timing_place_lookup.cpp

@@ -602,7 +602,6 @@ static bool check_non_configurable_edges(const Netlist<>& net_list,
                                          bool is_flat) {
     const auto& device_ctx = g_vpr_ctx.device();
     auto& route_ctx = g_vpr_ctx.mutable_routing();
-    auto& cluster_ctx = g_vpr_ctx.clustering();
 
     if(!route_ctx.rt_roots[net])  // no routing
         return true;
@@ -759,9 +758,7 @@ static bool check_non_configurable_edges(const Netlist<>& net_list,
 // are children of a configurable node have at least one sink.
 class StubFinder {
   public:
-    StubFinder(const Netlist<>& net_list, bool is_flat)
-        : net_list_(net_list)
-        , is_flat_(is_flat) {}
+    StubFinder() {}
 
     // Checks specified net for stubs, return true if at least one stub is
     // found.
@@ -779,8 +776,6 @@ class StubFinder {
     // Note this is an ordered set so that node output is sorted by node
     // id.
     std::set<int> stub_nodes_;
-    const Netlist<>& net_list_;
-    bool is_flat_;
 };
 
 //Cheks for stubs in a net's routing.
@@ -792,7 +787,7 @@ class StubFinder {
 void check_net_for_stubs(const Netlist<>& net_list,
                          ParentNetId net,
                          bool is_flat) {
-    StubFinder stub_finder(net_list, is_flat);
+    StubFinder stub_finder;
 
     bool any_stubs = stub_finder.CheckNet(net);
     if (any_stubs) {
@@ -806,6 +801,7 @@ void check_net_for_stubs(const Netlist<>& net_list,
                                                                 inode, is_flat)
                                                    .c_str());
         }
+        print_route_tree(g_vpr_ctx.routing().rt_roots[net].value());
 
         VPR_THROW(VPR_ERROR_ROUTE, msg.c_str());
     }

vpr/src/route/check_route.cpp

@@ -406,17 +406,11 @@ void init_route_structs(const Netlist<>& net_list,
                         int bb_factor,
                         bool has_choking_point,
                         bool is_flat) {
-    auto& cluster_ctx = g_vpr_ctx.clustering();
     auto& device_ctx = g_vpr_ctx.device();
     auto& route_ctx = g_vpr_ctx.mutable_routing();
 
-    // Free everything in current_rt
-    //for(auto rt_node : route_ctx.current_rt){
-    //    free_route_tree(rt_node);
-    //}
-
     // Allocate and clear a new rt_roots
-    route_ctx.rt_roots.resize(cluster_ctx.clb_nlist.nets().size());
+    route_ctx.rt_roots.resize(net_list.nets().size());
     std::fill(route_ctx.rt_roots.begin(), route_ctx.rt_roots.end(), vtr::nullopt);
 
     //Various look-ups

vpr/src/route/route_common.cpp

@@ -125,15 +125,13 @@ static void setup_routing_resources(int itry,
                                     CBRR& connections_inf,
                                     std::vector<vtr::optional<RouteTreeNode&>>& rt_node_of_sink,
                                     const t_router_opts& router_opts,
-                                    bool ripup_high_fanout_nets,
-                                    bool is_flat);
+                                    bool ripup_high_fanout_nets);
 
 static bool timing_driven_check_net_delays(const Netlist<>& net_list,
                                            NetPinsMatrix<float>& net_delay,
                                            bool is_flat);
 
 static bool should_route_net(ParentNetId net_id,
-                             const vtr::vector<ParentNetId, t_traceback>& net_trace,
                              CBRR& connections_inf,
                              bool if_force_reroute);
 
@@ -204,8 +202,7 @@ static void generate_route_timing_reports(const t_router_opts& router_opts,
                                           bool is_flat);
 
 static void prune_unused_non_configurable_nets(CBRR& connections_inf,
-                                               const Netlist<>& net_list,
-                                               bool is_flat);
+                                               const Netlist<>& net_list);
 
 static void init_net_delay_from_lookahead(const RouterLookahead& router_lookahead,
                                           const Netlist<>& net_list,
@@ -501,7 +498,7 @@ bool try_timing_driven_route_tmpl(const Netlist<>& net_list,
 
     RouterStats router_stats;
     init_route_stats(router_stats);
-    timing_driven_route_structs route_structs(std::max(get_max_pins_per_net(net_list) - 1, 0));
+    timing_driven_route_structs route_structs(net_list);
     float prev_iter_cumm_time = 0;
     vtr::Timer iteration_timer;
     int num_net_bounding_boxes_updated = 0;
@@ -895,7 +892,7 @@ bool try_timing_driven_route_tmpl(const Netlist<>& net_list,
         router_ctx.rt_roots = best_routing;
         router_ctx.clb_opins_used_locally = best_clb_opins_used_locally;
 
-        prune_unused_non_configurable_nets(connections_inf, net_list, is_flat);
+        prune_unused_non_configurable_nets(connections_inf, net_list);
 
         if (timing_info) {
             VTR_LOG("Critical path: %g ns\n", 1e9 * best_routing_metrics.critical_path.delay());
@@ -955,7 +952,7 @@ bool try_timing_driven_route_net(ConnectionRouter& router,
                                  RouterStats& router_stats,
                                  std::vector<float> pin_criticality,
                                  std::vector<vtr::optional<RouteTreeNode&>>& rt_node_of_sink,
-                                 ClbNetPinsMatrix<float>& net_delay,
+                                 NetPinsMatrix<float>& net_delay,
                                  const ClusteredPinAtomPinsLookup& netlist_pin_lookup,
                                  std::shared_ptr<SetupHoldTimingInfo> timing_info,
                                  NetPinTimingInvalidator* pin_timing_invalidator,
@@ -981,7 +978,7 @@ bool try_timing_driven_route_net(ConnectionRouter& router,
         is_routed = true;
     } else if (net_list.net_is_ignored(net_id)) { /* Skip ignored nets. */
         is_routed = true;
-    } else if (!(reroute_for_hold) && !should_route_net(net_id, route_ctx.trace, connections_inf, true)) {
+    } else if (!(reroute_for_hold) && !should_route_net(net_id, connections_inf, true)) {
         is_routed = true;
     } else {
         // track time spent vs fanout
@@ -1085,8 +1082,7 @@ bool timing_driven_route_net(ConnectionRouter& router,
         connections_inf,
         rt_node_of_sink,
         router_opts,
-        check_hold(router_opts, worst_neg_slack),
-        is_flat
+        check_hold(router_opts, worst_neg_slack)
     );
 
     VTR_ASSERT(route_ctx.rt_roots[net_id]);
@@ -1458,8 +1454,7 @@ static void setup_routing_resources(int itry,
                                     CBRR& connections_inf,
                                     std::vector<vtr::optional<RouteTreeNode&>>& rt_node_of_sink,
                                     const t_router_opts& router_opts,
-                                    bool ripup_high_fanout_nets,
-                                    bool is_flat) {
+                                    bool ripup_high_fanout_nets) {
     /* Build and return a partial route tree from the legal connections from last iteration.
      * along the way do:
      * 	update pathfinder costs to be accurate to the partial route tree
@@ -1510,7 +1505,7 @@ static void setup_routing_resources(int itry,
         VTR_ASSERT_SAFE(is_valid_skeleton_tree(rt_root.value()));
 
         // Skip this check if RCV is enabled, as RCV can use another method to cause reroutes
-        VTR_ASSERT_SAFE(should_route_net(net_id, route_ctx.trace, connections_inf, true) || router_opts.routing_budgets_algorithm == YOYO);
+        VTR_ASSERT_SAFE(should_route_net(net_id, connections_inf, true) || router_opts.routing_budgets_algorithm == YOYO);
 
         // Prune the copy (using congestion data before subtraction)
         vtr::optional<RouteTreeRoot&> rt_root_pruned = prune_route_tree(rt_root2, connections_inf);
@@ -2172,8 +2167,7 @@ static void generate_route_timing_reports(const t_router_opts& router_opts,
 // non-configurable sets. This function tracks non-configurable set usage,
 // and if the sets are unused, prunes them.
 static void prune_unused_non_configurable_nets(CBRR& connections_inf,
-                                               const Netlist<>& net_list,
-                                               bool is_flat) {
+                                               const Netlist<>& net_list) {
     auto& device_ctx = g_vpr_ctx.device();
     auto& route_ctx = g_vpr_ctx.mutable_routing();
 
@@ -2183,7 +2177,6 @@ static void prune_unused_non_configurable_nets(CBRR& connections_inf,
             continue;
         RouteTreeRoot& rt_root = route_ctx.rt_roots[net_id].value();
 
-
         connections_inf.prepare_routing_for_net(net_id);
         connections_inf.clear_force_reroute_for_net();
 

vpr/src/route/route_timing.cpp

@@ -2,6 +2,7 @@
 #include <unordered_map>
 #include <vector>
 #include "connection_based_routing.h"
+#include "netlist.h"
 #include "vpr_types.h"
 
 #include "vpr_utils.h"
@@ -94,8 +95,8 @@ class timing_driven_route_structs {
     std::vector<int> sink_order;             /* [1..max_pins_per_net-1] */
     std::vector<vtr::optional<RouteTreeNode&>> rt_node_of_sink; /* [1..max_pins_per_net-1] */
 
-    timing_driven_route_structs(){
-        int max_sinks = std::max(get_max_pins_per_net() - 1, 0);
+    timing_driven_route_structs(const Netlist<>& net_list){
+        int max_sinks = std::max(get_max_pins_per_net(net_list) - 1, 0);
         pin_criticality.resize(max_sinks+1);
         sink_order.resize(max_sinks+1);
         rt_node_of_sink.resize(max_sinks+1);