clip HF BB by original BB

Author: duck2

vpr/src/route/connection_router.cpp

@@ -964,16 +964,21 @@ void ConnectionRouter<Heap>::add_route_tree_node_to_heap(
     }
 }
 
-static t_bb adjust_highfanout_bounding_box(t_bb highfanout_bb) {
-    t_bb bb = highfanout_bb;
+/* Expand bb by inode's extents and clip against net_bb */
+inline void expand_highfanout_bounding_box(t_bb& bb, const t_bb& net_bb, RRNodeId inode, const RRGraphView* rr_graph) {
+    bb.xmin = std::max<int>(net_bb.xmin, std::min<int>(bb.xmin, rr_graph->node_xlow(inode)));
+    bb.ymin = std::max<int>(net_bb.ymin, std::min<int>(bb.ymin, rr_graph->node_ylow(inode)));
+    bb.xmax = std::min<int>(net_bb.xmax, std::max<int>(bb.xmax, rr_graph->node_xhigh(inode)));
+    bb.ymax = std::min<int>(net_bb.ymax, std::max<int>(bb.ymax, rr_graph->node_yhigh(inode)));
+}
 
+/* Expand bb by HIGH_FANOUT_BB_FAC and clip against net_bb */
+inline void adjust_highfanout_bounding_box(t_bb& bb, const t_bb& net_bb) {
     constexpr int HIGH_FANOUT_BB_FAC = 3;
-    bb.xmin -= HIGH_FANOUT_BB_FAC;
-    bb.ymin -= HIGH_FANOUT_BB_FAC;
-    bb.xmax += HIGH_FANOUT_BB_FAC;
-    bb.ymax += HIGH_FANOUT_BB_FAC;
-
-    return bb;
+    bb.xmin = std::max<int>(net_bb.xmin, bb.xmin - HIGH_FANOUT_BB_FAC);
+    bb.ymin = std::max<int>(net_bb.ymin, bb.ymin - HIGH_FANOUT_BB_FAC);
+    bb.xmax = std::min<int>(net_bb.xmax, bb.xmax + HIGH_FANOUT_BB_FAC);
+    bb.ymax = std::min<int>(net_bb.ymax, bb.ymax + HIGH_FANOUT_BB_FAC);
 }
 
 template<typename Heap>
@@ -1032,11 +1037,8 @@ t_bb ConnectionRouter<Heap>::add_high_fanout_route_tree_to_heap(
                 // Put the node onto the heap
                 add_route_tree_node_to_heap(rt_node, target_node, cost_params, true);
 
-                // Update Bounding Box
-                highfanout_bb.xmin = std::min<int>(highfanout_bb.xmin, rr_graph_->node_xlow(rr_node_to_add));
-                highfanout_bb.ymin = std::min<int>(highfanout_bb.ymin, rr_graph_->node_ylow(rr_node_to_add));
-                highfanout_bb.xmax = std::max<int>(highfanout_bb.xmax, rr_graph_->node_xhigh(rr_node_to_add));
-                highfanout_bb.ymax = std::max<int>(highfanout_bb.ymax, rr_graph_->node_yhigh(rr_node_to_add));
+                // Expand HF BB to include the node (clip by original BB)
+                expand_highfanout_bounding_box(highfanout_bb, net_bounding_box, rr_node_to_add, rr_graph_);
                 if (is_flat_) {
                     if (rr_graph_->node_type(rr_node_to_add) == CHANY || rr_graph_->node_type(rr_node_to_add) == CHANX) {
                         chan_nodes_added++;
@@ -1062,15 +1064,14 @@ t_bb ConnectionRouter<Heap>::add_high_fanout_route_tree_to_heap(
         if (done) break;
     }
 
-    t_bb bounding_box = net_bounding_box;
     if (nodes_added == 0) { //If the target bin, and it's surrounding bins were empty, just add the full route tree
         add_route_tree_to_heap(rt_root, target_node, cost_params, true);
+        return net_bounding_box;
     } else {
         //We found nearby routing, replace original bounding box to be localized around that routing
-        bounding_box = adjust_highfanout_bounding_box(highfanout_bb);
+        adjust_highfanout_bounding_box(highfanout_bb, net_bounding_box);
+        return highfanout_bb;
     }
-
-    return bounding_box;
 }
 
 std::unique_ptr<ConnectionRouterInterface> make_connection_router(e_heap_type heap_type,

vpr/src/route/route.cpp

@@ -6,6 +6,7 @@
 #include "read_route.h"
 #include "route.h"
 #include "route_common.h"
+#include "route_debug.h"
 #include "route_export.h"
 #include "route_profiling.h"
 #include "route_utils.h"

vpr/src/route/route_common.cpp

@@ -5,6 +5,7 @@
 #include "draw_global.h"
 #include "place_and_route.h"
 #include "route_common.h"
+#include "route_export.h"
 #include "rr_graph.h"
 
 /*  The numbering relation between the channels and clbs is:				*
@@ -36,7 +37,7 @@
  *            chan_width_y[0]        chan_width_y[1]                        *
  *                                                                          */
 
-/******************** Subroutines local to route_common.c *******************/
+/******************** Subroutines local to route_common.cpp *******************/
 static vtr::vector<ParentNetId, std::vector<RRNodeId>> load_net_rr_terminals(const RRGraphView& rr_graph,
                                                                              const Netlist<>& net_list,
                                                                              bool is_flat);
@@ -74,7 +75,7 @@ void save_routing(vtr::vector<ParentNetId, vtr::optional<RouteTree>>& best_routi
     saved_clb_opins_used_locally = clb_opins_used_locally;
 }
 
-/* Empties route_ctx.current_rt and copies over best_routing onto it.
+/* Empties route_ctx.route_trees and copies over best_routing onto it.
  * Also restores the locally used opin data. */
 void restore_routing(vtr::vector<ParentNetId, vtr::optional<RouteTree>>& best_routing,
                      t_clb_opins_used& clb_opins_used_locally,
@@ -117,46 +118,6 @@ void get_serial_num(const Netlist<>& net_list) {
     VTR_LOG("Serial number (magic cookie) for the routing is: %d\n", serial_num);
 }
 
-void try_graph(int width_fac,
-               const t_router_opts& router_opts,
-               t_det_routing_arch* det_routing_arch,
-               std::vector<t_segment_inf>& segment_inf,
-               t_chan_width_dist chan_width_dist,
-               t_direct_inf* directs,
-               int num_directs,
-               bool is_flat) {
-    auto& device_ctx = g_vpr_ctx.mutable_device();
-
-    t_graph_type graph_type;
-    t_graph_type graph_directionality;
-    if (router_opts.route_type == GLOBAL) {
-        graph_type = GRAPH_GLOBAL;
-        graph_directionality = GRAPH_BIDIR;
-    } else {
-        graph_type = (det_routing_arch->directionality == BI_DIRECTIONAL ? GRAPH_BIDIR : GRAPH_UNIDIR);
-        graph_directionality = (det_routing_arch->directionality == BI_DIRECTIONAL ? GRAPH_BIDIR : GRAPH_UNIDIR);
-    }
-
-    /* Set the channel widths */
-    t_chan_width chan_width = init_chan(width_fac, chan_width_dist, graph_directionality);
-
-    /* Free any old routing graph, if one exists. */
-    free_rr_graph();
-
-    /* Set up the routing resource graph defined by this FPGA architecture. */
-    int warning_count;
-    create_rr_graph(graph_type,
-                    device_ctx.physical_tile_types,
-                    device_ctx.grid,
-                    chan_width,
-                    det_routing_arch,
-                    segment_inf,
-                    router_opts,
-                    directs, num_directs,
-                    &warning_count,
-                    is_flat);
-}
-
 /** 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. */
@@ -211,10 +172,9 @@ vtr::vector<RRNodeId, std::set<ClusterNetId>> collect_rr_node_nets() {
     return rr_node_nets;
 }
 
+/** Updates pathfinder's occupancy by either adding or removing the
+ * usage of a resource node. */
 void pathfinder_update_single_node_occupancy(RRNodeId inode, int add_or_sub) {
-    /* Updates pathfinder's occupancy by either adding or removing the
-     * usage of a resource node. */
-
     auto& route_ctx = g_vpr_ctx.mutable_routing();
 
     int occ = route_ctx.rr_node_route_inf[inode].occ() + add_or_sub;
@@ -223,14 +183,13 @@ void pathfinder_update_single_node_occupancy(RRNodeId inode, int add_or_sub) {
     VTR_ASSERT(occ >= 0);
 }
 
+/** This routine recomputes the acc_cost (accumulated congestion cost) of each
+ * routing resource for the pathfinder algorithm after all nets have been routed.
+ * It updates the accumulated cost to by adding in the number of extra signals
+ * sharing a resource right now (i.e. after each complete iteration) times acc_fac.
+ * THIS ROUTINE ASSUMES THE OCCUPANCY VALUES IN RR_NODE ARE UP TO DATE.
+ * This routine also creates a new overuse info for the current routing iteration. */
 void pathfinder_update_acc_cost_and_overuse_info(float acc_fac, OveruseInfo& overuse_info) {
-    /* This routine recomputes the acc_cost (accumulated congestion cost) of each       *
-     * routing resource for the pathfinder algorithm after all nets have been routed.   *
-     * It updates the accumulated cost to by adding in the number of extra signals      *
-     * sharing a resource right now (i.e. after each complete iteration) times acc_fac. *
-     * THIS ROUTINE ASSUMES THE OCCUPANCY VALUES IN RR_NODE ARE UP TO DATE.             *
-     * This routine also creates a new overuse info for the current routing iteration.  */
-
     auto& device_ctx = g_vpr_ctx.device();
     const auto& rr_graph = device_ctx.rr_graph;
     auto& route_ctx = g_vpr_ctx.mutable_routing();
@@ -264,20 +223,6 @@ void pathfinder_update_cost_from_route_tree(const RouteTreeNode& root, int add_o
     }
 }
 
-float update_pres_fac(float new_pres_fac) {
-    /* This routine should take the new value of the present congestion factor *
-     * and propagate it to all the relevant data fields in the vpr flow.       *
-     * Currently, it only updates the pres_fac used by the drawing functions   */
-#ifndef NO_GRAPHICS
-
-    // Only updates the drawing pres_fac if graphics is enabled
-    get_draw_state_vars()->pres_fac = new_pres_fac;
-
-#endif // NO_GRAPHICS
-
-    return new_pres_fac;
-}
-
 /* Call this before you route any nets. It frees any old route trees and
  * sets the list of rr_nodes touched to empty. */
 void init_route_structs(const Netlist<>& net_list,
@@ -442,12 +387,9 @@ static t_clb_opins_used alloc_and_load_clb_opins_used_locally() {
     return (clb_opins_used_locally);
 }
 
-/*the trace lists are only freed after use by the timing-driven placer */
-/*Do not  free them after use by the router, since stats, and draw  */
-/*routines use the trace values */
+/* Frees the temporary storage needed only during the routing. The
+ * final routing result is not freed. */
 void free_route_structs() {
-    /* Frees the temporary storage needed only during the routing.  The  *
-     * final routing result is not freed.                                */
     auto& route_ctx = g_vpr_ctx.mutable_routing();
 
     if (route_ctx.route_bb.size() != 0) {

vpr/src/route/route_common.h

@@ -1,14 +1,16 @@
 #pragma once
 
-/** @file More router utils (mostly used by the connection router) */
+/** @file More router utils: some used by the connection router, some by other
+ * router files and some used globally */
 
 #include <vector>
 #include "clustered_netlist.h"
 #include "rr_node_fwd.h"
 #include "router_stats.h"
 #include "globals.h"
 
-/******* Subroutines in route_common used only by other router modules ******/
+bool feasible_routing();
+
 vtr::vector<ParentNetId, t_bb> load_route_bb(const Netlist<>& net_list,
                                              int bb_factor);
 
@@ -23,8 +25,6 @@ void pathfinder_update_acc_cost_and_overuse_info(float acc_fac, OveruseInfo& ove
 /** Update pathfinder cost of all nodes under root (including root) */
 void pathfinder_update_cost_from_route_tree(const RouteTreeNode& root, int add_or_sub);
 
-float update_pres_fac(float new_pres_fac);
-
 void reset_path_costs(const std::vector<RRNodeId>& visited_rr_nodes);
 
 float get_rr_cong_cost(RRNodeId inode, float pres_fac);

vpr/src/route/route_debug.cpp

@@ -0,0 +1,30 @@
+#include "route_debug.h"
+
+std::atomic_bool f_router_debug = false;
+
+void enable_router_debug(
+    const t_router_opts& router_opts,
+    ParentNetId net,
+    RRNodeId sink_rr,
+    int router_iteration,
+    ConnectionRouterInterface* router) {
+    bool active_net_debug = (router_opts.router_debug_net >= -1);
+    bool active_sink_debug = (router_opts.router_debug_sink_rr >= 0);
+    bool active_iteration_debug = (router_opts.router_debug_iteration >= 0);
+
+    bool match_net = (ParentNetId(router_opts.router_debug_net) == net || router_opts.router_debug_net == -1);
+    bool match_sink = (router_opts.router_debug_sink_rr == int(size_t((sink_rr))) || router_opts.router_debug_sink_rr < 0);
+    bool match_iteration = (router_opts.router_debug_iteration == router_iteration || router_opts.router_debug_iteration < 0);
+
+    f_router_debug = active_net_debug || active_sink_debug || active_iteration_debug;
+
+    if (active_net_debug) f_router_debug = f_router_debug && match_net;
+    if (active_sink_debug) f_router_debug = f_router_debug && match_sink;
+    if (active_iteration_debug) f_router_debug = f_router_debug && match_iteration;
+
+    router->set_router_debug(f_router_debug);
+
+#ifndef VTR_ENABLE_DEBUG_LOGGING
+    VTR_LOGV_WARN(f_router_debug, "Limited router debug output provided since compiled without VTR_ENABLE_DEBUG_LOGGING defined\n");
+#endif
+}

vpr/src/route/route_debug.h

@@ -0,0 +1,20 @@
+#pragma once
+
+/** @file Utils for debugging the router */
+
+#include <atomic>
+#include "connection_router_interface.h"
+#include "vpr_types.h"
+
+/** @brief Run-time flag to control when router debug information is printed
+ * Note only enables debug output if compiled with VTR_ENABLE_DEBUG_LOGGING defined
+ * f_router_debug is used to stop the router when a breakpoint is reached. When a breakpoint is reached, this flag is set to true.
+ *
+ * In addition f_router_debug is used to print additional debug information during routing, for instance lookahead expected costs
+ * information.
+ *
+ * d2: Made atomic as an attempt to make it work with parallel routing, but don't expect reliable results. */
+extern std::atomic_bool f_router_debug;
+
+/** Enable f_router_debug if specific sink/net debugging is set in \p router_opts */
+void enable_router_debug(const t_router_opts& router_opts, ParentNetId net, RRNodeId sink_rr, int router_iteration, ConnectionRouterInterface* router);

vpr/src/route/route_export.h

@@ -11,23 +11,10 @@
 
 #include "RoutingDelayCalculator.h"
 
-void try_graph(int width_fac,
-               const t_router_opts& router_opts,
-               t_det_routing_arch* det_routing_arch,
-               std::vector<t_segment_inf>& segment_inf,
-               t_chan_width_dist chan_width_dist,
-               t_direct_inf* directs,
-               int num_directs,
-               bool is_flat);
-
-bool feasible_routing();
-
 std::vector<RRNodeId> collect_congested_rr_nodes();
 
 vtr::vector<RRNodeId, std::set<ClusterNetId>> collect_rr_node_nets();
 
-t_clb_opins_used alloc_route_structs();
-
 void free_route_structs();
 
 void save_routing(vtr::vector<ParentNetId, vtr::optional<RouteTree>>& best_routing,