Add base cost option that is bounded.

Signed-off-by: Keith Rothman <[email protected]>

Author: litghost

vpr/src/base/ShowSetup.cpp

@@ -197,6 +197,9 @@ static void ShowRouterOpts(const t_router_opts& RouterOpts) {
             case DELAY_NORMALIZED_LENGTH:
                 VTR_LOG("DELAY_NORMALIZED_LENGTH\n");
                 break;
+            case DELAY_NORMALIZED_LENGTH_BOUNDED:
+                VTR_LOG("DELAY_NORMALIZED_LENGTH_BOUNDED\n");
+                break;
             case DELAY_NORMALIZED_FREQUENCY:
                 VTR_LOG("DELAY_NORMALIZED_FREQUENCY\n");
                 break;

vpr/src/base/read_options.cpp

@@ -245,6 +245,8 @@ struct ParseBaseCost {
             conv_value.set_value(DEMAND_ONLY_NORMALIZED_LENGTH);
         else if (str == "demand_only")
             conv_value.set_value(DEMAND_ONLY);
+        else if (str == "delay_normalized_length_bounded")
+            conv_value.set_value(DELAY_NORMALIZED_LENGTH_BOUNDED);
         else {
             std::stringstream msg;
             msg << "Invalid conversion from '" << str << "' to e_router_algorithm (expected one of: " << argparse::join(default_choices(), ", ") << ")";
@@ -265,6 +267,8 @@ struct ParseBaseCost {
             conv_value.set_value("delay_normalized_length_frequency");
         else if (val == DEMAND_ONLY_NORMALIZED_LENGTH)
             conv_value.set_value("demand_only_normalized_length");
+        else if (val == DELAY_NORMALIZED_LENGTH_BOUNDED)
+            conv_value.set_value("delay_normalized_length_bounded");
         else {
             VTR_ASSERT(val == DEMAND_ONLY);
             conv_value.set_value("demand_only");
@@ -273,7 +277,7 @@ struct ParseBaseCost {
     }
 
     std::vector<std::string> default_choices() {
-        return {"demand_only", "demand_only_normalized_length", "delay_normalized", "delay_normalized_length", "delay_normalized_frequency", "delay_normalized_length_frequency"};
+        return {"demand_only", "demand_only_normalized_length", "delay_normalized", "delay_normalized_length", "delay_normalized_length_bounded", "delay_normalized_frequency", "delay_normalized_length_frequency"};
     }
 };
 
@@ -1442,9 +1446,13 @@ argparse::ArgumentParser create_arg_parser(std::string prog_name, t_options& arg
             "      to magnitude of typical routing resource delay\n"
             " * delay_normalized_length: like delay_normalized but\n"
             "      scaled by routing resource length\n"
-            " * delay_normalized_freqeuncy: like delay_normalized\n"
+            " * delay_normalized_length_bounded: like delay_normalized but\n"
+            "      scaled by routing resource length.  Scaling is normalized\n"
+            "      between 1 to 4, with min lengths getting scaled at 1,\n"
+            "      and max lengths getting scaled at 4.\n"
+            " * delay_normalized_frequency: like delay_normalized\n"
             "      but scaled inversely by segment type frequency\n"
-            " * delay_normalized_length_freqeuncy: like delay_normalized\n"
+            " * delay_normalized_length_frequency: like delay_normalized\n"
             "      but scaled by routing resource length, and inversely\n"
             "      by segment type frequency\n"
             "(Default: demand_only for breadth-first router,\n"

vpr/src/base/vpr_types.h

@@ -878,6 +878,7 @@ enum e_base_cost_type {
     DELAY_NORMALIZED_LENGTH,
     DELAY_NORMALIZED_FREQUENCY,
     DELAY_NORMALIZED_LENGTH_FREQUENCY,
+    DELAY_NORMALIZED_LENGTH_BOUNDED,
     DEMAND_ONLY,
     DEMAND_ONLY_NORMALIZED_LENGTH
 };

vpr/src/route/rr_graph_indexed_data.cpp

@@ -168,6 +168,14 @@ static void load_rr_indexed_data_base_costs(int nodes_per_chan,
     size_t total_segments = std::accumulate(rr_segment_counts.begin(), rr_segment_counts.end(), 0u);
 
     /* Load base costs for CHANX and CHANY segments */
+    float max_length = 0;
+    float min_length = 1;
+    if (base_cost_type == DELAY_NORMALIZED_LENGTH_BOUNDED) {
+        for (index = CHANX_COST_INDEX_START; index < device_ctx.rr_indexed_data.size(); index++) {
+            float length = (1 / device_ctx.rr_indexed_data[index].inv_length);
+            max_length = std::max(max_length, length);
+        }
+    }
 
     //Future Work: Since we can now have wire types which don't connect to IPINs,
     //             perhaps consider lowering cost of wires which connect to IPINs
@@ -180,6 +188,15 @@ static void load_rr_indexed_data_base_costs(int nodes_per_chan,
         } else if (base_cost_type == DELAY_NORMALIZED_LENGTH || base_cost_type == DEMAND_ONLY_NORMALIZED_LENGTH) {
             device_ctx.rr_indexed_data[index].base_cost = delay_normalization_fac / device_ctx.rr_indexed_data[index].inv_length;
 
+        } else if (base_cost_type == DELAY_NORMALIZED_LENGTH_BOUNDED) {
+            float length = (1 / device_ctx.rr_indexed_data[index].inv_length);
+            if (max_length != min_length) {
+                float length_scale = 1.f + 3.f * (length - min_length) / (max_length - min_length);
+                device_ctx.rr_indexed_data[index].base_cost = delay_normalization_fac * length_scale;
+            } else {
+                device_ctx.rr_indexed_data[index].base_cost = delay_normalization_fac;
+            }
+
         } else if (base_cost_type == DELAY_NORMALIZED_FREQUENCY) {
             int seg_index = device_ctx.rr_indexed_data[index].seg_index;