make format

Author: duck2

vpr/src/base/vpr_api.cpp

@@ -922,19 +922,19 @@ RouteStatus vpr_route_fixed_W(const Netlist<>& net_list,
     }
     bool status = false;
     status = route(net_list,
-                    fixed_channel_width,
-                    vpr_setup.RouterOpts,
-                    vpr_setup.AnalysisOpts,
-                    &vpr_setup.RoutingArch,
-                    vpr_setup.Segments,
-                    net_delay,
-                    timing_info,
-                    delay_calc,
-                    arch.Chans,
-                    arch.Directs,
-                    arch.num_directs,
-                    ScreenUpdatePriority::MAJOR,
-                    is_flat);
+                   fixed_channel_width,
+                   vpr_setup.RouterOpts,
+                   vpr_setup.AnalysisOpts,
+                   &vpr_setup.RoutingArch,
+                   vpr_setup.Segments,
+                   net_delay,
+                   timing_info,
+                   delay_calc,
+                   arch.Chans,
+                   arch.Directs,
+                   arch.num_directs,
+                   ScreenUpdatePriority::MAJOR,
+                   is_flat);
 
     return RouteStatus(status, fixed_channel_width);
 }

vpr/src/route/netlist_routers.h

@@ -37,16 +37,16 @@ struct RouteIterResults {
 
 /** Route a given netlist. Takes a big context and passes it around to net & sink routing fns. */
 class NetlistRouter {
-public:
+  public:
     virtual ~NetlistRouter() {}
     virtual RouteIterResults route_netlist(int itry, float pres_fac, float worst_neg_slack) = 0;
     virtual void set_rcv_enabled(bool x) = 0;
     virtual void set_timing_info(std::shared_ptr<SetupHoldTimingInfo> timing_info) = 0;
 };
 
 template<typename HeapType>
-class SerialNetlistRouter: public NetlistRouter {
-public:
+class SerialNetlistRouter : public NetlistRouter {
+  public:
     SerialNetlistRouter(
         const Netlist<>& net_list,
         const RouterLookahead* router_lookahead,
@@ -59,27 +59,27 @@ class SerialNetlistRouter: public NetlistRouter {
         route_budgets& budgeting_inf,
         const RoutingPredictor& routing_predictor,
         const vtr::vector<ParentNetId, std::vector<std::unordered_map<RRNodeId, int>>>& choking_spots,
-        bool is_flat
-    ):
-    _router(_make_router(router_lookahead, is_flat)),
-    _net_list(net_list),
-    _router_opts(router_opts),
-    _connections_inf(connections_inf),
-    _net_delay(net_delay),
-    _netlist_pin_lookup(netlist_pin_lookup),
-    _timing_info(timing_info),
-    _pin_timing_invalidator(pin_timing_invalidator),
-    _budgeting_inf(budgeting_inf),
-    _routing_predictor(routing_predictor),
-    _choking_spots(choking_spots),
-    _is_flat(is_flat){}
+        bool is_flat)
+        : _router(_make_router(router_lookahead, is_flat))
+        , _net_list(net_list)
+        , _router_opts(router_opts)
+        , _connections_inf(connections_inf)
+        , _net_delay(net_delay)
+        , _netlist_pin_lookup(netlist_pin_lookup)
+        , _timing_info(timing_info)
+        , _pin_timing_invalidator(pin_timing_invalidator)
+        , _budgeting_inf(budgeting_inf)
+        , _routing_predictor(routing_predictor)
+        , _choking_spots(choking_spots)
+        , _is_flat(is_flat) {}
     ~SerialNetlistRouter() {}
 
     RouteIterResults route_netlist(int itry, float pres_fac, float worst_neg_slack);
     void set_rcv_enabled(bool x);
     void set_timing_info(std::shared_ptr<SetupHoldTimingInfo> timing_info);
-private:
-    ConnectionRouter<HeapType> _make_router(const RouterLookahead* router_lookahead, bool is_flat){
+
+  private:
+    ConnectionRouter<HeapType> _make_router(const RouterLookahead* router_lookahead, bool is_flat) {
         auto& device_ctx = g_vpr_ctx.device();
         auto& route_ctx = g_vpr_ctx.mutable_routing();
 
@@ -109,8 +109,8 @@ class SerialNetlistRouter: public NetlistRouter {
 };
 
 template<typename HeapType>
-class ParallelNetlistRouter: public NetlistRouter {
-public:
+class ParallelNetlistRouter : public NetlistRouter {
+  public:
     ParallelNetlistRouter(
         const Netlist<>& net_list,
         const RouterLookahead* router_lookahead,
@@ -123,28 +123,28 @@ class ParallelNetlistRouter: public NetlistRouter {
         route_budgets& budgeting_inf,
         const RoutingPredictor& routing_predictor,
         const vtr::vector<ParentNetId, std::vector<std::unordered_map<RRNodeId, int>>>& choking_spots,
-        bool is_flat
-    ):
-    _routers_th(_make_router(router_lookahead, is_flat)),
-    _net_list(net_list),
-    _router_opts(router_opts),
-    _connections_inf(connections_inf),
-    _net_delay(net_delay),
-    _netlist_pin_lookup(netlist_pin_lookup),
-    _timing_info(timing_info),
-    _pin_timing_invalidator(pin_timing_invalidator),
-    _budgeting_inf(budgeting_inf),
-    _routing_predictor(routing_predictor),
-    _choking_spots(choking_spots),
-    _is_flat(is_flat){}
+        bool is_flat)
+        : _routers_th(_make_router(router_lookahead, is_flat))
+        , _net_list(net_list)
+        , _router_opts(router_opts)
+        , _connections_inf(connections_inf)
+        , _net_delay(net_delay)
+        , _netlist_pin_lookup(netlist_pin_lookup)
+        , _timing_info(timing_info)
+        , _pin_timing_invalidator(pin_timing_invalidator)
+        , _budgeting_inf(budgeting_inf)
+        , _routing_predictor(routing_predictor)
+        , _choking_spots(choking_spots)
+        , _is_flat(is_flat) {}
     ~ParallelNetlistRouter() {}
 
     RouteIterResults route_netlist(int itry, float pres_fac, float worst_neg_slack);
     void set_rcv_enabled(bool x);
     void set_timing_info(std::shared_ptr<SetupHoldTimingInfo> timing_info);
-private:
+
+  private:
     void route_partition_tree_node(tbb::task_group& g, PartitionTreeNode& node, int itry, float pres_fac, float worst_neg_slack);
-    ConnectionRouter<HeapType> _make_router(const RouterLookahead* router_lookahead, bool is_flat){
+    ConnectionRouter<HeapType> _make_router(const RouterLookahead* router_lookahead, bool is_flat) {
         auto& device_ctx = g_vpr_ctx.device();
         auto& route_ctx = g_vpr_ctx.mutable_routing();
 
@@ -187,8 +187,8 @@ inline std::unique_ptr<NetlistRouter> make_netlist_router_with_heap(
     route_budgets& budgeting_inf,
     const RoutingPredictor& routing_predictor,
     const vtr::vector<ParentNetId, std::vector<std::unordered_map<RRNodeId, int>>>& choking_spots,
-    bool is_flat){
-    if(router_opts.router_algorithm == e_router_algorithm::TIMING_DRIVEN){
+    bool is_flat) {
+    if (router_opts.router_algorithm == e_router_algorithm::TIMING_DRIVEN) {
         return std::make_unique<SerialNetlistRouter<HeapType>>(
             net_list,
             router_lookahead,
@@ -202,7 +202,7 @@ inline std::unique_ptr<NetlistRouter> make_netlist_router_with_heap(
             routing_predictor,
             choking_spots,
             is_flat);
-    }else if(router_opts.router_algorithm == e_router_algorithm::PARALLEL){
+    } else if (router_opts.router_algorithm == e_router_algorithm::PARALLEL) {
 #ifdef VPR_USE_TBB
         return std::make_unique<ParallelNetlistRouter<HeapType>>(
             net_list,
@@ -220,7 +220,7 @@ inline std::unique_ptr<NetlistRouter> make_netlist_router_with_heap(
 #else
         VPR_FATAL_ERROR(VPR_ERROR_ROUTE, "VPR isn't compiled with TBB support required for parallel routing");
 #endif
-    }else{
+    } else {
         VPR_FATAL_ERROR(VPR_ERROR_ROUTE, "Unknown router algorithm %d", router_opts.router_algorithm);
     }
 }
@@ -239,7 +239,7 @@ inline std::unique_ptr<NetlistRouter> make_netlist_router(
     const RoutingPredictor& routing_predictor,
     const vtr::vector<ParentNetId, std::vector<std::unordered_map<RRNodeId, int>>>& choking_spots,
     bool is_flat) {
-    if(router_opts.router_heap == e_heap_type::BINARY_HEAP){
+    if (router_opts.router_heap == e_heap_type::BINARY_HEAP) {
         return make_netlist_router_with_heap<BinaryHeap>(
             net_list,
             router_lookahead,
@@ -252,9 +252,8 @@ inline std::unique_ptr<NetlistRouter> make_netlist_router(
             budgeting_inf,
             routing_predictor,
             choking_spots,
-            is_flat
-        );
-    }else if(router_opts.router_heap == e_heap_type::BUCKET_HEAP_APPROXIMATION){
+            is_flat);
+    } else if (router_opts.router_heap == e_heap_type::BUCKET_HEAP_APPROXIMATION) {
         return make_netlist_router_with_heap<Bucket>(
             net_list,
             router_lookahead,
@@ -267,10 +266,8 @@ inline std::unique_ptr<NetlistRouter> make_netlist_router(
             budgeting_inf,
             routing_predictor,
             choking_spots,
-            is_flat
-        );
-    }else{
+            is_flat);
+    } else {
         VPR_FATAL_ERROR(VPR_ERROR_ROUTE, "Unknown heap type %d", router_opts.router_heap);
     }
 }
-

vpr/src/route/parallel_netlist_router.cpp

@@ -5,8 +5,8 @@
 /** A parallel netlist router. Builds a PartitionTree from the netlist depending on bounding boxes
  * and goes over it with a tbb::task_group. Is not expected to use more than 2 effective threads on avg. */
 template<typename HeapType>
-RouteIterResults ParallelNetlistRouter<HeapType>::route_netlist(int itry, float pres_fac, float worst_neg_slack){
-    for(auto& results: _results_th){
+RouteIterResults ParallelNetlistRouter<HeapType>::route_netlist(int itry, float pres_fac, float worst_neg_slack) {
+    for (auto& results : _results_th) {
         results = RouteIterResults();
     }
 
@@ -26,7 +26,7 @@ RouteIterResults ParallelNetlistRouter<HeapType>::route_netlist(int itry, float
 }
 
 template<typename HeapType>
-void ParallelNetlistRouter<HeapType>::route_partition_tree_node(tbb::task_group& g, PartitionTreeNode& node, int itry, float pres_fac, float worst_neg_slack){
+void ParallelNetlistRouter<HeapType>::route_partition_tree_node(tbb::task_group& g, PartitionTreeNode& node, int itry, float pres_fac, float worst_neg_slack) {
     auto& route_ctx = g_vpr_ctx.mutable_routing();
 
     /* Sort so net with most sinks is routed first. */
@@ -83,18 +83,17 @@ void ParallelNetlistRouter<HeapType>::route_partition_tree_node(tbb::task_group&
 }
 
 template<typename HeapType>
-void ParallelNetlistRouter<HeapType>::set_rcv_enabled(bool x){
-    for(auto& router: _routers_th){
+void ParallelNetlistRouter<HeapType>::set_rcv_enabled(bool x) {
+    for (auto& router : _routers_th) {
         router.set_rcv_enabled(x);
     }
 }
 
 template<typename HeapType>
-void ParallelNetlistRouter<HeapType>::set_timing_info(std::shared_ptr<SetupHoldTimingInfo> timing_info){
+void ParallelNetlistRouter<HeapType>::set_timing_info(std::shared_ptr<SetupHoldTimingInfo> timing_info) {
     _timing_info = timing_info;
 }
 
-
 /** Explicit instantiation so that the compiler knows it should emit code for these cases */
 template class ParallelNetlistRouter<BinaryHeap>;
 template class ParallelNetlistRouter<Bucket>;

vpr/src/route/route.cpp

@@ -187,15 +187,15 @@ bool route(const Netlist<>& net_list,
     int legal_convergence_count = 0;
 
     /* Get initial criticalities from the lookahead */
-    if(router_opts.with_timing_analysis && router_opts.initial_timing == e_router_initial_timing::LOOKAHEAD){
+    if (router_opts.with_timing_analysis && router_opts.initial_timing == e_router_initial_timing::LOOKAHEAD) {
         vtr::ScopedStartFinishTimer init_timing_timer("Initializing router criticalities");
         //Estimate initial connection delays from the router lookahead
         init_net_delay_from_lookahead(*router_lookahead,
-                                        net_list,
-                                        route_ctx.net_rr_terminals,
-                                        net_delay,
-                                        device_ctx.rr_graph,
-                                        is_flat);
+                                      net_list,
+                                      route_ctx.net_rr_terminals,
+                                      net_delay,
+                                      device_ctx.rr_graph,
+                                      is_flat);
 
         //Run STA to get estimated criticalities
         timing_info->update();
@@ -225,8 +225,7 @@ bool route(const Netlist<>& net_list,
         budgeting_inf,
         routing_predictor,
         choking_spots,
-        is_flat
-    );
+        is_flat);
 
     RouterStats router_stats;
     float prev_iter_cumm_time = 0;
@@ -265,15 +264,15 @@ bool route(const Netlist<>& net_list,
         }
 
         /* Initial criticalities: set to 1 on the first iter if the user asked for it */
-        if(router_opts.initial_timing == e_router_initial_timing::ALL_CRITICAL && itry == 1)
+        if (router_opts.initial_timing == e_router_initial_timing::ALL_CRITICAL && itry == 1)
             netlist_router->set_timing_info(make_constant_timing_info(1));
         else
             netlist_router->set_timing_info(timing_info);
 
         /* Route each net */
         RouteIterResults iter_results = netlist_router->route_netlist(itry, pres_fac, worst_negative_slack);
 
-        if(!iter_results.is_routable){ /* Disconnected RRG */
+        if (!iter_results.is_routable) { /* Disconnected RRG */
             return false;
         }
 
@@ -351,7 +350,7 @@ bool route(const Netlist<>& net_list,
                 success = true;
 
                 //Update best metrics
-                if(router_opts.with_timing_analysis){
+                if (router_opts.with_timing_analysis) {
                     check_net_delays(net_list, net_delay);
                     best_routing_metrics.sTNS = timing_info->setup_total_negative_slack();
                     best_routing_metrics.sWNS = timing_info->setup_worst_negative_slack();
@@ -601,7 +600,7 @@ bool route(const Netlist<>& net_list,
 #endif
     }
 
-    if(router_opts.with_timing_analysis){
+    if (router_opts.with_timing_analysis) {
         VTR_LOG("Final Net Connection Criticality Histogram:\n");
         print_router_criticality_histogram(net_list, *timing_info, netlist_pin_lookup, is_flat);
     }

vpr/src/route/route_common.cpp

@@ -158,8 +158,8 @@ void try_graph(int width_fac,
 }
 
 /** This routine checks to see if this is a resource-feasible routing.
-* That is, are all rr_node capacity limitations respected?  It assumes
-* that the occupancy arrays are up to date when it is called. */
+ * That is, are all rr_node capacity limitations respected?  It assumes
+ * that the occupancy arrays are up to date when it is called. */
 bool feasible_routing() {
     auto& device_ctx = g_vpr_ctx.device();
     const auto& rr_graph = device_ctx.rr_graph;

vpr/src/route/route_net.cpp

@@ -206,12 +206,12 @@ bool early_exit_heuristic(const t_router_opts& router_opts, const WirelengthInfo
 }
 
 float get_net_pin_criticality(const SetupHoldTimingInfo* timing_info,
-                                const ClusteredPinAtomPinsLookup& netlist_pin_lookup,
-                                float max_criticality,
-                                float criticality_exp,
-                                ParentNetId net_id,
-                                ParentPinId pin_id,
-                                bool is_flat) {
+                              const ClusteredPinAtomPinsLookup& netlist_pin_lookup,
+                              float max_criticality,
+                              float criticality_exp,
+                              ParentNetId net_id,
+                              ParentPinId pin_id,
+                              bool is_flat) {
     float pin_criticality = 0.0;
     const auto& route_ctx = g_vpr_ctx.routing();
 
@@ -363,7 +363,6 @@ bool early_reconvergence_exit_heuristic(const t_router_opts& router_opts,
     return false; // Don't give up
 }
 
-
 // Initializes net_delay based on best-case delay estimates from the router lookahead
 void init_net_delay_from_lookahead(const RouterLookahead& router_lookahead,
                                    const Netlist<>& net_list,
@@ -399,10 +398,10 @@ void init_net_delay_from_lookahead(const RouterLookahead& router_lookahead,
 /** Goes through all the sinks of this net and copies their delay values from
  * the route_tree to the net_delay array. */
 void update_net_delays_from_route_tree(float* net_delay,
-                                    const Netlist<>& net_list,
-                                    ParentNetId inet,
-                                    TimingInfo* timing_info,
-                                    NetPinTimingInvalidator* pin_timing_invalidator) {
+                                       const Netlist<>& net_list,
+                                       ParentNetId inet,
+                                       TimingInfo* timing_info,
+                                       NetPinTimingInvalidator* pin_timing_invalidator) {
     auto& route_ctx = g_vpr_ctx.routing();
     const RouteTree& tree = route_ctx.route_trees[inet].value();