Standardized and renamed packer alpha and beta variable. They are now referred to as timing_gain_weight and connection_gain_weight, used as a weight parameter during timing and connection driven clustering respectively.

yenjames · yenjames · commit d3f1dba918a0 · 2025-04-27T14:35:18.000-04:00
diff --git a/doc/src/vpr/command_line_usage.rst b/doc/src/vpr/command_line_usage.rst
@@ -569,15 +569,15 @@ For people not working on CAD, you can probably leave all the options to their d
 
     **Default**:  ``auto``
 
-.. option:: --alpha_clustering <float>
+.. option:: --timing_gain_weight <float>
 
     A parameter that weights the optimization of timing vs area.
 
     A value of 0 focuses solely on area, a value of 1 focuses entirely on timing.
 
     **Default**: ``0.75``
 
-.. option:: --beta_clustering <float>
+.. option:: --connection_gain_weight <float>
 
     A tradeoff parameter that controls the optimization of smaller net absorption vs. the optimization of signal sharing.
 
diff --git a/vpr/src/base/SetupVPR.cpp b/vpr/src/base/SetupVPR.cpp
@@ -580,8 +580,8 @@ void SetupPackerOpts(const t_options& Options,
     PackerOpts->connection_driven = Options.connection_driven_clustering;
     PackerOpts->timing_driven = Options.timing_driven_clustering;
     PackerOpts->cluster_seed_type = Options.cluster_seed_type;
-    PackerOpts->alpha = Options.alpha_clustering;
-    PackerOpts->beta = Options.beta_clustering;
+    PackerOpts->timing_gain_weight = Options.timing_gain_weight;
+    PackerOpts->connection_gain_weight = Options.connection_gain_weight;
     PackerOpts->pack_verbosity = Options.pack_verbosity;
     PackerOpts->enable_pin_feasibility_filter = Options.enable_clustering_pin_feasibility_filter;
     PackerOpts->balance_block_type_utilization = Options.balance_block_type_utilization;
diff --git a/vpr/src/base/ShowSetup.cpp b/vpr/src/base/ShowSetup.cpp
@@ -731,8 +731,8 @@ static void ShowPackerOpts(const t_packer_opts& PackerOpts) {
     } else {
         VPR_FATAL_ERROR(VPR_ERROR_UNKNOWN, "Unknown packer allow_unrelated_clustering\n");
     }
-    VTR_LOG("PackerOpts.alpha_clustering: %f\n", PackerOpts.alpha);
-    VTR_LOG("PackerOpts.beta_clustering: %f\n", PackerOpts.beta);
+    VTR_LOG("PackerOpts.timing_gain_weight: %f\n", PackerOpts.timing_gain_weight);
+    VTR_LOG("PackerOpts.connection_gain_weight: %f\n", PackerOpts.connection_gain_weight);
     VTR_LOG("PackerOpts.cluster_seed_type: ");
     switch (PackerOpts.cluster_seed_type) {
         case e_cluster_seed::TIMING:
diff --git a/vpr/src/base/read_options.cpp b/vpr/src/base/read_options.cpp
@@ -1972,14 +1972,14 @@ argparse::ArgumentParser create_arg_parser(const std::string& prog_name, t_optio
         .default_value("auto")
         .show_in(argparse::ShowIn::HELP_ONLY);
 
-    pack_grp.add_argument(args.alpha_clustering, "--alpha_clustering")
+    pack_grp.add_argument(args.timing_gain_weight, "--timing_gain_weight")
         .help(
             "Parameter that weights the optimization of timing vs area. 0.0 focuses solely on"
             " area, 1.0 solely on timing.")
         .default_value("0.75")
         .show_in(argparse::ShowIn::HELP_ONLY);
 
-    pack_grp.add_argument(args.beta_clustering, "--beta_clustering")
+    pack_grp.add_argument(args.connection_gain_weight, "--connection_gain_weight")
         .help(
             "Parameter that weights the absorption of small nets vs signal sharing."
             " 0.0 focuses solely on sharing, 1.0 solely on small net absoprtion."
diff --git a/vpr/src/base/read_options.h b/vpr/src/base/read_options.h
@@ -108,8 +108,8 @@ struct t_options {
     /* Clustering options */
     argparse::ArgValue<bool> connection_driven_clustering;
     argparse::ArgValue<e_unrelated_clustering> allow_unrelated_clustering;
-    argparse::ArgValue<float> alpha_clustering;
-    argparse::ArgValue<float> beta_clustering;
+    argparse::ArgValue<float> timing_gain_weight;
+    argparse::ArgValue<float> connection_gain_weight;
     argparse::ArgValue<bool> timing_driven_clustering;
     argparse::ArgValue<e_cluster_seed> cluster_seed_type;
     argparse::ArgValue<bool> enable_clustering_pin_feasibility_filter;
diff --git a/vpr/src/base/vpr_types.h b/vpr/src/base/vpr_types.h
@@ -714,6 +714,17 @@ enum e_stage_action {
  *          ALWAYS TRUE. (Default: True)
  *   @param timing_driven
  *          Whether or not to do timing driven clustering. (Default: on)
+ *   @param timing_gain_weight
+ *          Controls the optimization of timing vs area in timing driven
+ *          clustering. 
+ *          A value of 0 focuses only on area; 1 focuses only on timing.
+ *          (Default: 0.75)
+ *   @param connection_gain_weight
+ *          Controls the optimization of smaller net absorption vs. signal 
+ *          sharing in connection driven clustering. 
+ *          A value of 0 focuses solely on signal sharing; a value of 1 
+ *          focuses solely on absorbing smaller nets into a cluster. 
+ *          (Default: 0.9)
  *   @param cluster_seed_type
  *          Selection algorithm for selecting next seed. (Default: blend2 if 
  *          timing_driven is on; max_inputs otherwise)
@@ -777,8 +788,9 @@ struct t_packer_opts {
     bool global_clocks;
     bool timing_driven;
     enum e_cluster_seed cluster_seed_type;
-    float alpha;
-    float beta;
+    float timing_gain_weight;
+    float connection_gain_weight;
+    float inter_cluster_net_delay;
     float target_device_utilization;
     e_unrelated_clustering allow_unrelated_clustering;
     bool connection_driven;
diff --git a/vpr/src/pack/greedy_candidate_selector.cpp b/vpr/src/pack/greedy_candidate_selector.cpp
@@ -620,9 +620,9 @@ void GreedyCandidateSelector::update_total_gain(ClusterGainStats& cluster_gain_s
         VTR_ASSERT(num_used_pins > 0);
         if (packer_opts_.connection_driven) {
             /*try to absorb as many connections as possible*/
-            cluster_gain_stats.gain[blk_id] = ((1 - packer_opts_.beta)
+            cluster_gain_stats.gain[blk_id] = ((1 - packer_opts_.connection_gain_weight)
                                                    * (float)cluster_gain_stats.sharing_gain[blk_id]
-                                               + packer_opts_.beta * (float)cluster_gain_stats.connection_gain[blk_id])
+                                               + packer_opts_.connection_gain_weight * (float)cluster_gain_stats.connection_gain[blk_id])
                                               / (num_used_pins);
         } else {
             cluster_gain_stats.gain[blk_id] = ((float)cluster_gain_stats.sharing_gain[blk_id])
@@ -631,9 +631,9 @@ void GreedyCandidateSelector::update_total_gain(ClusterGainStats& cluster_gain_s
 
         /* Add in timing driven cost into cost function */
         if (packer_opts_.timing_driven) {
-            cluster_gain_stats.gain[blk_id] = packer_opts_.alpha
+            cluster_gain_stats.gain[blk_id] = packer_opts_.timing_gain_weight
                                                   * cluster_gain_stats.timing_gain[blk_id]
-                                              + (1.0 - packer_opts_.alpha) * (float)cluster_gain_stats.gain[blk_id];
+                                              + (1.0 - packer_opts_.timing_gain_weight) * (float)cluster_gain_stats.gain[blk_id];
         }
     }
 }
