move t_rr_node_route_inf from rr_node_type.h to route_commmon.h

Author: soheilshahrouz

libs/librrgraph/src/base/rr_node_types.h

@@ -128,45 +128,3 @@ struct t_rr_rc_data {
 // This is the data type of fast lookups of an rr-node given an (rr_type, layer, x, y, and the side)
 //[0..num_rr_types-1][0..num_layer-1][0..grid_width-1][0..grid_height-1][0..NUM_2D_SIDES-1][0..max_ptc-1]
 typedef vtr::array<e_rr_type, vtr::NdMatrix<std::vector<RRNodeId>, 4>, (size_t)e_rr_type::NUM_RR_TYPES> t_rr_node_indices;
-
-/**
- * @brief Extra information about each rr_node needed only during routing
- *        (i.e. during the maze expansion).
- */
-struct t_rr_node_route_inf {
-    /** ID of the edge (globally unique edge ID in the RR Graph)
-     *  that was used to reach this node from the previous node.
-     *  If there is no predecessor, prev_edge = NO_PREVIOUS.
-     */
-    RREdgeId prev_edge;
-
-    /** Accumulated cost term from previous Pathfinder iterations. */
-    float acc_cost;
-
-    /** Total cost of the path up to and including this node +
-     *  the expected cost to the target if the timing_driven router
-     *  is being used.
-     */
-    float path_cost;
-
-    /** Total cost of the path up to and including this node. */
-    float backward_path_cost;
-
-    /** Upstream resistance to ground from this node in the current
-     *  path search (connection routing), including the resistance
-     *  of the node itself (device_ctx.rr_nodes[index].R).
-     */
-    float R_upstream;
-
-  public: // Accessors
-    /** @return The current occupancy of the associated rr node. */
-    short occ() const { return occ_; }
-
-  public: // Mutators
-    /** @param new_occ The new occupancy to set. */
-    void set_occ(int new_occ) { occ_ = new_occ; }
-
-  private: // Data
-    /** The current occupancy of the associated rr node. */
-    short occ_ = 0;
-};

vpr/src/base/globals.cpp

@@ -1,3 +1,4 @@
 #include "globals.h"
+#include "route_common.h"
 
 VprContext g_vpr_ctx;

vpr/src/base/old_traceback.cpp

@@ -3,6 +3,7 @@
 #include "clustered_netlist_fwd.h"
 #include "globals.h"
 #include "vtr_assert.h"
+#include "route_common.h"
 
 #include <vector>
 

vpr/src/base/vpr_context.h

@@ -43,6 +43,7 @@
 
 class SetupHoldTimingInfo;
 class PostClusterDelayCalculator;
+struct t_rr_node_route_inf;
 
 #endif /* NO_SERVER */
 

vpr/src/route/overuse_report.cpp

@@ -5,6 +5,7 @@
 #include "physical_types_util.h"
 #include "vpr_utils.h"
 #include "vtr_log.h"
+#include "route_common.h"
 
 /**
  * @brief Definitions of global and helper routines related to printing RR node overuse info.

vpr/src/route/route_common.cpp

@@ -1,9 +1,10 @@
 /** @file Impls for more router utils */
 
+#include "route_common.h"
+
 #include "atom_netlist_utils.h"
 #include "connection_router_interface.h"
 #include "describe_rr_node.h"
-#include "route_common.h"
 #include "logic_types.h"
 #include "physical_types_util.h"
 #include "route_export.h"

vpr/src/route/route_common.h

@@ -7,6 +7,48 @@
 #include "router_stats.h"
 #include "globals.h"
 
+/**
+ * @brief Extra information about each rr_node needed only during routing
+ *        (i.e. during the maze expansion).
+ */
+struct t_rr_node_route_inf {
+    /** ID of the edge (globally unique edge ID in the RR Graph)
+     *  that was used to reach this node from the previous node.
+     *  If there is no predecessor, prev_edge = NO_PREVIOUS.
+     */
+    RREdgeId prev_edge;
+
+    /** Accumulated cost term from previous Pathfinder iterations. */
+    float acc_cost;
+
+    /** Total cost of the path up to and including this node +
+     *  the expected cost to the target if the timing_driven router
+     *  is being used.
+     */
+    float path_cost;
+
+    /** Total cost of the path up to and including this node. */
+    float backward_path_cost;
+
+    /** Upstream resistance to ground from this node in the current
+     *  path search (connection routing), including the resistance
+     *  of the node itself (device_ctx.rr_nodes[index].R).
+     */
+    float R_upstream;
+
+  public: // Accessors
+    /** @return The current occupancy of the associated rr node. */
+    short occ() const { return occ_; }
+
+  public: // Mutators
+    /** @param new_occ The new occupancy to set. */
+    void set_occ(int new_occ) { occ_ = new_occ; }
+
+  private: // Data
+    /** The current occupancy of the associated rr node. */
+    short occ_ = 0;
+};
+
 /** 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. */

vpr/src/route/route_path_manager.cpp

@@ -1,5 +1,6 @@
 #include "route_path_manager.h"
 #include "vpr_context.h"
+#include "route_common.h"
 
 PathManager::PathManager() {
     // Only init data structure if required by RCV
@@ -23,7 +24,7 @@ bool PathManager::node_exists_in_tree(t_heap_path* path_data,
         }
     }
 
-    // Search through route tree set for nodes existance
+    // Search through route tree set for nodes existence
     auto node_exists_in_route_tree = route_tree_nodes_.find(to_node);
 
     if (node_exists_in_route_tree != route_tree_nodes_.end()) {
@@ -70,7 +71,7 @@ void PathManager::alloc_path_struct(t_heap_path*& tptr) {
     // if (tptr == nullptr) {
     // Use a free node list to avoid unnecessary data allocation
     // If there are unused data structures in memory use these
-    if (freed_nodes_.size() > 0) {
+    if (!freed_nodes_.empty()) {
         tptr = freed_nodes_.back();
         freed_nodes_.pop_back();
     } else {

vpr/src/route/route_tree.cpp

@@ -4,6 +4,7 @@
 #include "globals.h"
 #include "netlist_fwd.h"
 #include "route_debug.h"
+#include "route_common.h"
 #include "rr_graph_fwd.h"
 #include "vtr_math.h"
 
@@ -13,7 +14,7 @@ RouteTreeNode::RouteTreeNode(RRNodeId _inode, RRSwitchId _parent_switch, RouteTr
     : inode(_inode)
     , parent_switch(_parent_switch)
     , _parent(parent) {
-    auto& device_ctx = g_vpr_ctx.device();
+    const auto& device_ctx = g_vpr_ctx.device();
     const auto& rr_graph = device_ctx.rr_graph;
 
     re_expand = true;

vpr/src/route/route_utils.cpp

@@ -272,7 +272,15 @@ void print_overused_nodes_status(const t_router_opts& router_opts, const Overuse
     VTR_LOG("\n");
 }
 
-void print_route_status(int itry, double elapsed_sec, float pres_fac, int num_bb_updated, const RouterStats& router_stats, const OveruseInfo& overuse_info, const WirelengthInfo& wirelength_info, std::shared_ptr<const SetupHoldTimingInfo> timing_info, float est_success_iteration) {
+void print_route_status(int itry,
+                        double elapsed_sec,
+                        float pres_fac,
+                        int num_bb_updated,
+                        const RouterStats& router_stats,
+                        const OveruseInfo& overuse_info,
+                        const WirelengthInfo& wirelength_info,
+                        std::shared_ptr<const SetupHoldTimingInfo> timing_info,
+                        float est_success_iteration) {
     //Iteration
     VTR_LOG("%4d", itry);
 

vpr/src/route/route_utils.h

@@ -10,8 +10,6 @@
 
 #include "RoutingDelayCalculator.h"
 
-constexpr float CONGESTED_SLOPE_VAL = -0.04;
-
 /** Identifies the two breakpoint types in routing */
 typedef enum router_breakpoint_type {
     BP_ROUTE_ITER,
@@ -105,7 +103,15 @@ bool is_iteration_complete(bool routing_is_feasible, const t_router_opts& router
 
 void print_overused_nodes_status(const t_router_opts& router_opts, const OveruseInfo& overuse_info);
 
-void print_route_status(int itry, double elapsed_sec, float pres_fac, int num_bb_updated, const RouterStats& router_stats, const OveruseInfo& overuse_info, const WirelengthInfo& wirelength_info, std::shared_ptr<const SetupHoldTimingInfo> timing_info, float est_success_iteration);
+void print_route_status(int itry,
+                        double elapsed_sec,
+                        float pres_fac,
+                        int num_bb_updated,
+                        const RouterStats& router_stats,
+                        const OveruseInfo& overuse_info,
+                        const WirelengthInfo& wirelength_info,
+                        std::shared_ptr<const SetupHoldTimingInfo> timing_info,
+                        float est_success_iteration);
 
 void print_route_status_header();
 

vpr/src/route/segment_stats.cpp

@@ -1,12 +1,14 @@
 
-#include "vtr_log.h"
+#include "segment_stats.h"
 
+#include "vtr_log.h"
 #include "globals.h"
-#include "segment_stats.h"
+#include "route_common.h"
+
 
 /*************** Variables and defines local to this module ****************/
 
-#define LONGLINE 0
+static constexpr int LONGLINE = 0;
 
 /******************* Subroutine definitions ********************************/
 
@@ -33,11 +35,11 @@ void get_segment_usage_stats(std::vector<t_segment_inf>& segment_inf) {
         {X_AXIS, std::map<int, int>()},
         {Y_AXIS, std::map<int, int>()}};
 
-    std::set<int, std::less<int>> segment_lengths;
-    for (const auto& seg_inf : segment_inf) {
+    std::set<int, std::less<>> segment_lengths;
+    for (const t_segment_inf& seg_inf : segment_inf) {
         int seg_length = seg_inf.longline ? LONGLINE : seg_inf.length;
 
-        for (auto ax : {X_AXIS, Y_AXIS}) {
+        for (e_parallel_axis ax : {X_AXIS, Y_AXIS}) {
             directed_cap_by_length[ax].insert({seg_length, 0});
             directed_occ_by_length[ax].insert({seg_length, 0});
         }
@@ -56,15 +58,15 @@ void get_segment_usage_stats(std::vector<t_segment_inf>& segment_inf) {
         {Y_AXIS, std::vector<int>(segment_inf.size(), 0)}};
 
     for (RRNodeId inode : device_ctx.rr_graph.nodes()) {
-        auto node_type = rr_graph.node_type(inode);
+        e_rr_type node_type = rr_graph.node_type(inode);
         if (node_type == e_rr_type::CHANX || node_type == e_rr_type::CHANY) {
             cost_index = rr_graph.node_cost_index(inode);
             size_t seg_type = device_ctx.rr_indexed_data[cost_index].seg_index;
             int length = segment_inf[seg_type].longline ? LONGLINE : segment_inf[seg_type].length;
 
             const short& inode_capacity = rr_graph.node_capacity(inode);
             int occ = route_ctx.rr_node_route_inf[inode].occ();
-            auto ax = (node_type == e_rr_type::CHANX) ? X_AXIS : Y_AXIS;
+            e_parallel_axis ax = (node_type == e_rr_type::CHANX) ? X_AXIS : Y_AXIS;
 
             directed_occ_by_length[ax][length] += occ;
             directed_cap_by_length[ax][length] += inode_capacity;
@@ -77,8 +79,8 @@ void get_segment_usage_stats(std::vector<t_segment_inf>& segment_inf) {
     VTR_LOG("\n");
     VTR_LOG("Total Number of Wiring Segments by Direction: direction length number\n");
     VTR_LOG("                                              --------- ------ -------\n");
-    for (auto length : segment_lengths) {
-        for (auto ax : {X_AXIS, Y_AXIS}) {
+    for (int length : segment_lengths) {
+        for (e_parallel_axis ax : {X_AXIS, Y_AXIS}) {
             std::string ax_name = (ax == X_AXIS) ? "X" : "Y";
             if (directed_cap_by_length[ax][length] != 0) {
                 std::string length_str = (length == LONGLINE) ? "longline" : std::to_string(length);
@@ -92,12 +94,12 @@ void get_segment_usage_stats(std::vector<t_segment_inf>& segment_inf) {
         }
     }
 
-    for (auto ax : {X_AXIS, Y_AXIS}) {
+    for (e_parallel_axis ax : {X_AXIS, Y_AXIS}) {
         std::string ax_name = (ax == X_AXIS) ? "X" : "Y";
         VTR_LOG("\n");
         VTR_LOG("%s - Directed Wiring Segment usage by length: length utilization\n", ax_name.c_str());
         VTR_LOG("                                             ------ -----------\n");
-        for (auto length : segment_lengths) {
+        for (int length : segment_lengths) {
             if (directed_cap_by_length[ax][length] != 0) {
                 std::string length_str = (length == LONGLINE) ? "longline" : std::to_string(length);
                 utilization = (float)directed_occ_by_length[ax][length] / (float)directed_cap_by_length[ax][length];
@@ -112,13 +114,13 @@ void get_segment_usage_stats(std::vector<t_segment_inf>& segment_inf) {
     VTR_LOG("\n");
     VTR_LOG("Segment occupancy by length: Length utilization\n");
     VTR_LOG("                             ------ -----------\n");
-    for (const auto& seg_length : segment_lengths) {
+    for (const int seg_length : segment_lengths) {
         if (directed_cap_by_length[X_AXIS][seg_length] != 0 || directed_cap_by_length[Y_AXIS][seg_length] != 0) {
             std::string seg_name = "L" + std::to_string(seg_length);
 
             int occ = 0;
             int cap = 0;
-            for (auto ax : {X_AXIS, Y_AXIS}) {
+            for (e_parallel_axis ax : {X_AXIS, Y_AXIS}) {
                 occ += directed_occ_by_length[ax][seg_length];
                 cap += directed_cap_by_length[ax][seg_length];
             }
@@ -137,7 +139,7 @@ void get_segment_usage_stats(std::vector<t_segment_inf>& segment_inf) {
             int seg_name_size = static_cast<int>(seg_name.size());
             int occ = 0;
             int cap = 0;
-            for (auto ax : {X_AXIS, Y_AXIS}) {
+            for (e_parallel_axis ax : {X_AXIS, Y_AXIS}) {
                 occ += directed_occ_by_type[ax][seg_type];
                 cap += directed_cap_by_type[ax][seg_type];
             }