verilog-to-routing · soheilshahrouz · May 1, 2025 · May 1, 2025 · May 2, 2025 · May 2, 2025
diff --git a/libs/librrgraph/src/base/check_rr_graph.cpp b/libs/librrgraph/src/base/check_rr_graph.cpp
@@ -53,9 +53,9 @@ void check_rr_graph(const RRGraphView& rr_graph,
                     const t_chan_width& chan_width,
                     const e_graph_type graph_type,
                     bool is_flat) {
-    e_route_type route_type = DETAILED;
+    e_route_type route_type = e_route_type::DETAILED;
     if (graph_type == e_graph_type::GLOBAL) {
-        route_type = GLOBAL;
+        route_type = e_route_type::GLOBAL;
     }
 
     auto total_edges_to_node = std::vector<int>(rr_graph.num_nodes());
@@ -420,7 +420,7 @@ void check_rr_node(const RRGraphView& rr_graph,
                 VPR_FATAL_ERROR(VPR_ERROR_ROUTE,
                                 "in check_rr_node: CHANX out of range for endpoints (%d,%d) and (%d,%d)\n", xlow, ylow, xhigh, yhigh);
             }
-            if (route_type == GLOBAL && xlow != xhigh) {
+            if (route_type == e_route_type::GLOBAL && xlow != xhigh) {
                 VPR_ERROR(VPR_ERROR_ROUTE,
                           "in check_rr_node: node %d spans multiple channel segments (not allowed for global routing).\n", inode);
             }
@@ -431,7 +431,7 @@ void check_rr_node(const RRGraphView& rr_graph,
                 VPR_FATAL_ERROR(VPR_ERROR_ROUTE,
                                 "Error in check_rr_node: CHANY out of range for endpoints (%d,%d) and (%d,%d)\n", xlow, ylow, xhigh, yhigh);
             }
-            if (route_type == GLOBAL && ylow != yhigh) {
+            if (route_type == e_route_type::GLOBAL && ylow != yhigh) {
                 VPR_ERROR(VPR_ERROR_ROUTE,
                           "in check_rr_node: node %d spans multiple channel segments (not allowed for global routing).\n", inode);
             }
@@ -480,7 +480,7 @@ void check_rr_node(const RRGraphView& rr_graph,
 
         case e_rr_type::CHANX:
         case e_rr_type::CHANY:
-            if (route_type == DETAILED) {
+            if (route_type == e_route_type::DETAILED) {
                 nodes_per_chan = chan_width.max;
                 tracks_per_node = 1;
             } else {

diff --git a/libs/librrgraph/src/base/rr_graph_type.h b/libs/librrgraph/src/base/rr_graph_type.h
@@ -13,7 +13,8 @@ struct t_chan_width {
     std::vector<int> y_list;
 };
 
-enum e_route_type {
+/// @brief Specifies whether global routing or combined global and detailed routing is performed.
+enum class e_route_type {
     GLOBAL,
     DETAILED
 };

diff --git a/libs/librrgraph/src/base/rr_node_types.h b/libs/librrgraph/src/base/rr_node_types.h
@@ -103,8 +103,8 @@ typedef vtr::Range<edge_idx_iterator> edge_idx_range;
 
 typedef std::vector<std::map<int, int>> t_arch_switch_fanin;
 
-/*
- * Resistance/Capacitance data for an RR Nodes
+/**
+ * @brief Resistance/Capacitance data for an RR Node.
  *
  * In practice many RR nodes have the same values, so they are fly-weighted
  * to keep t_rr_node small. Each RR node holds an rc_index which allows
@@ -121,8 +121,8 @@ typedef std::vector<std::map<int, int>> t_arch_switch_fanin;
 struct t_rr_rc_data {
     t_rr_rc_data(float Rval, float Cval) noexcept;
 
-    float R;
-    float C;
+    float R;    ///< Resistance to go through an RR node
+    float C;    ///<  Total capacitance of an RR node.
 };
 
 // This is the data type of fast lookups of an rr-node given an (rr_type, layer, x, y, and the side)

diff --git a/libs/librrgraph/src/base/rr_rc_data.h b/libs/librrgraph/src/base/rr_rc_data.h
@@ -2,8 +2,8 @@
 
 #include "rr_node_types.h"
 
-/*
- * Returns the index to a t_rr_rc_data matching the specified values.
+/**
+ * @brief Returns the index to a t_rr_rc_data matching the specified values.
  *
  * If an existing t_rr_rc_data matches the specified R/C it's index
  * is returned, otherwise the t_rr_rc_data is created.

diff --git a/libs/libvtrutil/src/vtr_assert.h b/libs/libvtrutil/src/vtr_assert.h
@@ -101,7 +101,7 @@
  *
  * Note that to avoid 'unused' variable warnings when assertions are
  * disabled, we pass the expr and msg to sizeof(). We use sizeof specifically
- * since it accepts expressions, and the C++ standard gaurentees sizeof's arguments
+ * since it accepts expressions, and the C++ standard guarantees sizeof's arguments
  * are never evaluated (ensuring any expensive expressions are not evaluated when
  * assertions are disabled). To avoid warnings about the unused result of sizeof()
  * we cast it to void.
@@ -140,7 +140,7 @@ namespace assert {
  * function will never return. This should ensure the
  * compiler won't warn about detected conditions such as
  * dead-code or potential null pointer dereferences
- * which are gaurded against by assertions.
+ * which are guarded against by assertions.
  */
 [[noreturn]] void handle_assert(const char* expr, const char* file, unsigned int line, const char* function, const char* msg);
 } // namespace assert

diff --git a/libs/libvtrutil/src/vtr_prefix_sum.h b/libs/libvtrutil/src/vtr_prefix_sum.h
@@ -123,6 +123,11 @@ class PrefixSum1D {
         return prefix_sum_[upper_x + 1] - prefix_sum_[lower_x];
     }
 
+    /// @brief Checks if the prefix sum is initialized or it is empty.
+    bool empty() const {
+        return prefix_sum_.empty();
+    }
+
   private:
     /**
      * @brief The 1D prefix sum of the original array of values.
@@ -268,6 +273,11 @@ class PrefixSum2D {
                + prefix_sum_[lower_x][lower_y];
     }
 
+    /// @brief Checks if the prefix sum is initialized or it is empty.
+    bool empty() const {
+        return prefix_sum_.empty();
+    }
+
   private:
     /**
      * @brief The 2D prefix sum of the original grid of values.

diff --git a/vpr/src/analytical_place/detailed_placer.cpp b/vpr/src/analytical_place/detailed_placer.cpp
@@ -101,7 +101,7 @@ void AnnealerDetailedPlacer::optimize_placement() {
     placer_->place();
 
     // Copy the placement solution into the global placement solution.
-    placer_->copy_locs_to_global_state(g_vpr_ctx.mutable_placement());
+    placer_->update_global_state();
 
     // Since the placement was modified, need to resynchronize the pins in the
     // clusters.

diff --git a/vpr/src/base/CheckSetup.cpp b/vpr/src/base/CheckSetup.cpp
@@ -34,8 +34,8 @@ void CheckSetup(const t_packer_opts& packer_opts,
         }
     }
 
-    if ((GLOBAL == router_opts.route_type)
-        && (placer_opts.place_algorithm.is_timing_driven())) {
+    if (e_route_type::GLOBAL == router_opts.route_type
+        && placer_opts.place_algorithm.is_timing_driven()) {
         /* Works, but very weird.  Can't optimize timing well, since you're
          * not doing proper architecture delay modelling. */
         VTR_LOG_WARN(
@@ -100,7 +100,7 @@ void CheckSetup(const t_packer_opts& packer_opts,
         }
     }
 
-    if (DETAILED == router_opts.route_type) {
+    if (e_route_type::DETAILED == router_opts.route_type) {
         if ((chans.chan_x_dist.type != UNIFORM)
             || (chans.chan_y_dist.type != UNIFORM)) {
             VPR_FATAL_ERROR(VPR_ERROR_OTHER,

diff --git a/vpr/src/base/SetupVPR.cpp b/vpr/src/base/SetupVPR.cpp
@@ -488,6 +488,9 @@ static void SetupRouterOpts(const t_options& Options, t_router_opts* RouterOpts)
     RouterOpts->router_debug_sink_rr = Options.router_debug_sink_rr;
     RouterOpts->router_debug_iteration = Options.router_debug_iteration;
     RouterOpts->lookahead_type = Options.router_lookahead_type;
+    RouterOpts->initial_acc_cost_chan_congestion_threshold = Options.router_initial_acc_cost_chan_congestion_threshold;
+    RouterOpts->initial_acc_cost_chan_congestion_weight = Options.router_initial_acc_cost_chan_congestion_weight;
+
     RouterOpts->max_convergence_count = Options.router_max_convergence_count;
     RouterOpts->reconvergence_cpd_threshold = Options.router_reconvergence_cpd_threshold;
     RouterOpts->initial_timing = Options.router_initial_timing;

diff --git a/vpr/src/base/ShowSetup.cpp b/vpr/src/base/ShowSetup.cpp
@@ -224,10 +224,10 @@ static void ShowAnnealSched(const t_annealing_sched& AnnealSched) {
 static void ShowRouterOpts(const t_router_opts& RouterOpts) {
     VTR_LOG("RouterOpts.route_type: ");
     switch (RouterOpts.route_type) {
-        case GLOBAL:
+        case e_route_type::GLOBAL:
             VTR_LOG("GLOBAL\n");
             break;
-        case DETAILED:
+        case e_route_type::DETAILED:
             VTR_LOG("DETAILED\n");
             break;
         default:
@@ -248,7 +248,7 @@ static void ShowRouterOpts(const t_router_opts& RouterOpts) {
         VTR_LOG("off\n");
     }
 
-    VTR_ASSERT(GLOBAL == RouterOpts.route_type || DETAILED == RouterOpts.route_type);
+    VTR_ASSERT(e_route_type::GLOBAL == RouterOpts.route_type || e_route_type::DETAILED == RouterOpts.route_type);
 
     VTR_LOG("RouterOpts.router_algorithm: ");
     switch (RouterOpts.router_algorithm) {
@@ -266,9 +266,9 @@ static void ShowRouterOpts(const t_router_opts& RouterOpts) {
             break;
         default:
             switch (RouterOpts.route_type) {
-                case DETAILED:
+                case e_route_type::DETAILED:
                     VPR_FATAL_ERROR(VPR_ERROR_UNKNOWN, "<Unknown>\n");
-                case GLOBAL:
+                case e_route_type::GLOBAL:
                     VTR_LOG_ERROR("Unknown router algorithm\n");
                     break;
                 default:
@@ -282,31 +282,31 @@ static void ShowRouterOpts(const t_router_opts& RouterOpts) {
             VTR_LOG("DELAY_NORMALIZED\n");
             break;
         case DELAY_NORMALIZED_LENGTH:
-            if (GLOBAL == RouterOpts.route_type) {
+            if (e_route_type::GLOBAL == RouterOpts.route_type) {
                 VTR_LOG_ERROR("Unknown router base cost type\n");
                 break;
             }
 
             VTR_LOG("DELAY_NORMALIZED_LENGTH\n");
             break;
         case DELAY_NORMALIZED_LENGTH_BOUNDED:
-            if (GLOBAL == RouterOpts.route_type) {
+            if (e_route_type::GLOBAL == RouterOpts.route_type) {
                 VTR_LOG_ERROR("Unknown router base cost type\n");
                 break;
             }
 
             VTR_LOG("DELAY_NORMALIZED_LENGTH_BOUNDED\n");
             break;
         case DELAY_NORMALIZED_FREQUENCY:
-            if (GLOBAL == RouterOpts.route_type) {
+            if (e_route_type::GLOBAL == RouterOpts.route_type) {
                 VTR_LOG_ERROR("Unknown router base cost type\n");
                 break;
             }
 
             VTR_LOG("DELAY_NORMALIZED_FREQUENCY\n");
             break;
         case DELAY_NORMALIZED_LENGTH_FREQUENCY:
-            if (GLOBAL == RouterOpts.route_type) {
+            if (e_route_type::GLOBAL == RouterOpts.route_type) {
                 VTR_LOG_ERROR("Unknown router base cost type\n");
                 break;
             }
@@ -317,7 +317,7 @@ static void ShowRouterOpts(const t_router_opts& RouterOpts) {
             VTR_LOG("DEMAND_ONLY\n");
             break;
         case DEMAND_ONLY_NORMALIZED_LENGTH:
-            if (GLOBAL == RouterOpts.route_type) {
+            if (e_route_type::GLOBAL == RouterOpts.route_type) {
                 VTR_LOG_ERROR("Unknown router base cost type\n");
                 break;
             }
@@ -326,9 +326,9 @@ static void ShowRouterOpts(const t_router_opts& RouterOpts) {
             break;
         default:
             switch (RouterOpts.route_type) {
-                case DETAILED:
+                case e_route_type::DETAILED:
                     VPR_FATAL_ERROR(VPR_ERROR_UNKNOWN, "Unknown base_cost_type\n");
-                case GLOBAL:
+                case e_route_type::GLOBAL:
                     VTR_LOG_ERROR("Unknown router base cost type\n");
                     break;
                 default:
@@ -343,7 +343,7 @@ static void ShowRouterOpts(const t_router_opts& RouterOpts) {
         VTR_LOG("%d\n", RouterOpts.fixed_channel_width);
     }
 
-    if (DETAILED == RouterOpts.route_type) {
+    if (e_route_type::DETAILED == RouterOpts.route_type) {
         VTR_LOG("RouterOpts.check_route: ");
         switch (RouterOpts.check_route) {
             case e_check_route_option::OFF:
@@ -389,7 +389,7 @@ static void ShowRouterOpts(const t_router_opts& RouterOpts) {
         VTR_LOG("RouterOpts.max_criticality: %f\n", RouterOpts.max_criticality);
         VTR_LOG("RouterOpts.init_wirelength_abort_threshold: %f\n", RouterOpts.init_wirelength_abort_threshold);
 
-        if (GLOBAL == RouterOpts.route_type)
+        if (e_route_type::GLOBAL == RouterOpts.route_type)
             VTR_LOG("RouterOpts.incr_reroute_delay_ripup: %f\n", RouterOpts.incr_reroute_delay_ripup);
         else {
             std::string incr_delay_ripup_opts[3] = {"ON", "OFF", "AUTO"};
@@ -468,7 +468,7 @@ static void ShowRouterOpts(const t_router_opts& RouterOpts) {
         }
     }
 
-    if (DETAILED == RouterOpts.route_type) {
+    if (e_route_type::DETAILED == RouterOpts.route_type) {
         if (RouterOpts.routing_failure_predictor == SAFE)
             VTR_LOG("RouterOpts.routing_failure_predictor = SAFE\n");
         else if (RouterOpts.routing_failure_predictor == AGGRESSIVE)

diff --git a/vpr/src/base/globals.cpp b/vpr/src/base/globals.cpp
@@ -1,3 +1,4 @@
 #include "globals.h"
+#include "route_common.h"
 
 VprContext g_vpr_ctx;
diff --git a/vpr/src/base/old_traceback.cpp b/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>
 

diff --git a/vpr/src/base/place_and_route.cpp b/vpr/src/base/place_and_route.cpp
@@ -79,7 +79,7 @@ int binary_search_place_and_route(const Netlist<>& placement_net_list,
 
     /* Allocate the major routing structures. */
 
-    if (router_opts.route_type == GLOBAL) {
+    if (router_opts.route_type == e_route_type::GLOBAL) {
         graph_type = e_graph_type::GLOBAL;
         graph_directionality = e_graph_type::BIDIR;
     } else {
@@ -376,8 +376,8 @@ int binary_search_place_and_route(const Netlist<>& placement_net_list,
 
     init_draw_coords(final, g_vpr_ctx.placement().blk_loc_registry());
 
-    /* Allocate and load additional rr_graph information needed only by the router. */
-    alloc_and_load_rr_node_route_structs();
+    // Allocate and load additional rr_graph information needed only by the router.
+    alloc_and_load_rr_node_route_structs(router_opts);
 
     init_route_structs(router_net_list,
                        router_opts.bb_factor,
@@ -424,7 +424,7 @@ t_chan_width setup_chan_width(const t_router_opts& router_opts,
         width_fac = router_opts.fixed_channel_width;
     }
 
-    if (router_opts.route_type == GLOBAL) {
+    if (router_opts.route_type == e_route_type::GLOBAL) {
         graph_directionality = e_graph_type::BIDIR;
     } else {
         graph_directionality = e_graph_type::UNIDIR;

diff --git a/vpr/src/base/read_options.cpp b/vpr/src/base/read_options.cpp
@@ -432,9 +432,9 @@ struct ParseRouteType {
     ConvertedValue<e_route_type> from_str(const std::string& str) {
         ConvertedValue<e_route_type> conv_value;
         if (str == "global")
-            conv_value.set_value(GLOBAL);
+            conv_value.set_value(e_route_type::GLOBAL);
         else if (str == "detailed")
-            conv_value.set_value(DETAILED);
+            conv_value.set_value(e_route_type::DETAILED);
         else {
             std::stringstream msg;
             msg << "Invalid conversion from '" << str << "' to e_router_algorithm (expected one of: " << argparse::join(default_choices(), ", ") << ")";
@@ -445,10 +445,10 @@ struct ParseRouteType {
 
     ConvertedValue<std::string> to_str(e_route_type val) {
         ConvertedValue<std::string> conv_value;
-        if (val == GLOBAL)
+        if (val == e_route_type::GLOBAL)
             conv_value.set_value("global");
         else {
-            VTR_ASSERT(val == DETAILED);
+            VTR_ASSERT(val == e_route_type::DETAILED);
             conv_value.set_value("detailed");
         }
         return conv_value;
@@ -2895,6 +2895,20 @@ argparse::ArgumentParser create_arg_parser(const std::string& prog_name, t_optio
         .default_value("map")
         .show_in(argparse::ShowIn::HELP_ONLY);
 
+    route_timing_grp.add_argument<double>(args.router_initial_acc_cost_chan_congestion_threshold, "--router_initial_acc_cost_chan_congestion_threshold")
+        .help("Utilization threshold above which initial accumulated routing cost (acc_cost) "
+              "is increased to penalize congested channels. Used to bias routing away from "
+              "highly utilized regions during early routing iterations.")
+        .default_value("0.5")
+        .show_in(argparse::ShowIn::HELP_ONLY);
+
+    route_timing_grp.add_argument<double>(args.router_initial_acc_cost_chan_congestion_weight, "--router_initial_acc_cost_chan_congestion_weight")
+        .help("Weight applied to the excess channel utilization (above threshold) "
+              "when computing the initial accumulated cost (acc_cost)of routing resources. "
+              "Higher values make the router more sensitive to early congestion.")
+        .default_value("0.5")
+        .show_in(argparse::ShowIn::HELP_ONLY);
+
     route_timing_grp.add_argument(args.router_max_convergence_count, "--router_max_convergence_count")
         .help(
             "Controls how many times the router is allowed to converge to a legal routing before halting."
@@ -3429,25 +3443,25 @@ void set_conditional_defaults(t_options& args) {
      */
     //Base cost type
     if (args.base_cost_type.provenance() != Provenance::SPECIFIED) {
-        if (args.RouteType == DETAILED) {
+        if (args.RouteType == e_route_type::DETAILED) {
             if (args.timing_analysis) {
                 args.base_cost_type.set(DELAY_NORMALIZED_LENGTH, Provenance::INFERRED);
             } else {
                 args.base_cost_type.set(DEMAND_ONLY_NORMALIZED_LENGTH, Provenance::INFERRED);
             }
         } else {
-            VTR_ASSERT(args.RouteType == GLOBAL);
+            VTR_ASSERT(args.RouteType == e_route_type::GLOBAL);
             //Global RR graphs don't have valid timing, so use demand base cost
             args.base_cost_type.set(DEMAND_ONLY_NORMALIZED_LENGTH, Provenance::INFERRED);
         }
     }
 
     //Bend cost
     if (args.bend_cost.provenance() != Provenance::SPECIFIED) {
-        if (args.RouteType == GLOBAL) {
+        if (args.RouteType == e_route_type::GLOBAL) {
             args.bend_cost.set(1., Provenance::INFERRED);
         } else {
-            VTR_ASSERT(args.RouteType == DETAILED);
+            VTR_ASSERT(args.RouteType == e_route_type::DETAILED);
             args.bend_cost.set(0., Provenance::INFERRED);
         }
     }