Add raw setup slack analysis to placement quench

doc/src/vpr/command_line_usage.rst

@@ -862,6 +862,16 @@ The following options are only valid when the placement engine is in timing-driv
 
     Name of the post-placement timing report file to generate (not generated if unspecfied).
 
+.. option:: --place_quench_metric {auto, timing_cost, setup_slack}
+
+    Specifies which cost formulation the placer uses during the quench stage.
+
+     * ``auto`` VPR makes the choice. Currently, VPR uses ``timing_cost`` by default.
+     * ``timing_cost`` Use the timing cost: connection delay * criticality.
+     * ``setup_slack`` Directly checks the raw setup slack returned by the timing analyzer.
+
+    **Default:** ``auto``
+
 .. _router_options:
 
 Router Options

vpr/src/base/SetupVPR.cpp

@@ -570,6 +570,8 @@ static void SetupPlacerOpts(const t_options& Options, t_placer_opts* PlacerOpts)
 
     PlacerOpts->effort_scaling = Options.place_effort_scaling;
     PlacerOpts->timing_update_type = Options.timing_update_type;
+
+    PlacerOpts->place_quench_metric = Options.place_quench_metric;
 }
 
 static void SetupAnalysisOpts(const t_options& Options, t_analysis_opts& analysis_opts) {

vpr/src/base/read_options.cpp

@@ -959,6 +959,41 @@ struct ParseTimingUpdateType {
     }
 };
 
+struct ParsePlaceQuenchMetric {
+    ConvertedValue<e_place_quench_metric> from_str(std::string str) {
+        ConvertedValue<e_place_quench_metric> conv_value;
+        if (str == "auto")
+            conv_value.set_value(e_place_quench_metric::AUTO);
+        else if (str == "timing_cost")
+            conv_value.set_value(e_place_quench_metric::TIMING_COST);
+        else if (str == "setup_slack")
+            conv_value.set_value(e_place_quench_metric::SETUP_SLACK);
+        else {
+            std::stringstream msg;
+            msg << "Invalid conversion from '" << str << "' to e_place_quench_metric (expected one of: " << argparse::join(default_choices(), ", ") << ")";
+            conv_value.set_error(msg.str());
+        }
+        return conv_value;
+    }
+
+    ConvertedValue<std::string> to_str(e_place_quench_metric val) {
+        ConvertedValue<std::string> conv_value;
+        if (val == e_place_quench_metric::AUTO)
+            conv_value.set_value("auto");
+        if (val == e_place_quench_metric::TIMING_COST)
+            conv_value.set_value("timing_cost");
+        else {
+            VTR_ASSERT(val == e_place_quench_metric::SETUP_SLACK);
+            conv_value.set_value("setup_slack");
+        }
+        return conv_value;
+    }
+
+    std::vector<std::string> default_choices() {
+        return {"auto", "timing_cost", "setup_slack"};
+    }
+};
+
 argparse::ArgumentParser create_arg_parser(std::string prog_name, t_options& args) {
     std::string description =
         "Implements the specified circuit onto the target FPGA architecture"
@@ -1747,6 +1782,17 @@ argparse::ArgumentParser create_arg_parser(std::string prog_name, t_options& arg
         .default_value("")
         .show_in(argparse::ShowIn::HELP_ONLY);
 
+    place_timing_grp.add_argument<e_place_quench_metric, ParsePlaceQuenchMetric>(args.place_quench_metric, "--place_quench_metric")
+        .help(
+            "Controls which cost function the placer uses during the quench stage:\n"
+            " * auto: VPR decides\n"
+            " * timing_cost: The same cost formulation as the one used during\n"
+            "                the annealing stage (more stable)\n"
+            " * setup_slack: Directly uses setup slacks (in combination with wiring)\n"
+            "                to check if the block moves should be accepted\n")
+        .default_value("auto")
+        .show_in(argparse::ShowIn::HELP_ONLY);
+
     auto& route_grp = parser.add_argument_group("routing options");
 
     route_grp.add_argument(args.max_router_iterations, "--max_router_iterations")

vpr/src/base/read_options.h

@@ -130,6 +130,7 @@ struct t_options {
     argparse::ArgValue<PlaceDelayModelType> place_delay_model;
     argparse::ArgValue<e_reducer> place_delay_model_reducer;
     argparse::ArgValue<std::string> allowed_tiles_for_delay_model;
+    argparse::ArgValue<e_place_quench_metric> place_quench_metric;
 
     /* Router Options */
     argparse::ArgValue<bool> check_rr_graph;

vpr/src/base/vpr_types.h

@@ -851,7 +851,8 @@ struct t_annealing_sched {
  * doPlacement: true if placement is supposed to be done in the CAD flow, false otherwise */
 enum e_place_algorithm {
     BOUNDING_BOX_PLACE,
-    PATH_TIMING_DRIVEN_PLACE
+    PATH_TIMING_DRIVEN_PLACE,
+    SETUP_SLACK_ANALYSIS_PLACE
 };
 
 enum e_place_effort_scaling {
@@ -884,6 +885,12 @@ enum class e_place_delta_delay_algorithm {
     DIJKSTRA_EXPANSION,
 };
 
+enum class e_place_quench_metric {
+    TIMING_COST,
+    SETUP_SLACK,
+    AUTO
+};
+
 struct t_placer_opts {
     enum e_place_algorithm place_algorithm;
     float timing_tradeoff;
@@ -932,6 +939,7 @@ struct t_placer_opts {
     std::string allowed_tiles_for_delay_model;
 
     e_place_delta_delay_algorithm place_delta_delay_matrix_calculation_method;
+    e_place_quench_metric place_quench_metric;
 };
 
 /* All the parameters controlling the router's operation are in this        *