Add raw setup slack analysis to placement quench

doc/src/vpr/command_line_usage.rst

@@ -700,16 +700,24 @@ If any of init_t, exit_t or alpha_t is specified, the user schedule, with a fixe
 
     **Default:** ``not_locked``.
 
-.. option:: --place_algorithm {bounding_box | path_timing_driven}
+.. option:: --place_algorithm {bounding_box | criticality_timing | slack_timing}
 
     Controls the algorithm used by the placer.
 
-    ``bounding_box`` focuses purely on minimizing the bounding box wirelength of the circuit.
+    ``bounding_box`` Focuses purely on minimizing the bounding box wirelength of the circuit. Turns off timing analysis if specified.
 
-    ``path_timing_driven`` focuses on minimizing both wirelength and the critical path delay.
+    ``criticality_timing`` Focuses on minimizing both the wirelength and the connection timing costs (criticality * delay).
 
+    ``slack_timing`` Focuses on improving the circuit slack values to reduce critical path delay.
 
-    **Default:**  ``path_timing_driven``
+    **Default:**  ``criticality_timing``
+
+.. option:: --place_quench_algorithm {bounding_box | criticality_timing | slack_timing}
+
+    Controls the algorithm used by the placer during placement quench.
+    The algorithm options have identical functionality as the ones used by the option ``--place_algorithm``.
+
+    **Default:**  ``criticality_timing``
 
 .. option:: --place_chan_width <int>
 

vpr/src/base/CheckSetup.cpp

@@ -23,7 +23,7 @@ void CheckSetup(const t_packer_opts& PackerOpts,
     }
 
     if ((GLOBAL == RouterOpts.route_type)
-        && (BOUNDING_BOX_PLACE != PlacerOpts.place_algorithm)) {
+        && (PlacerOpts.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(
@@ -32,7 +32,7 @@ void CheckSetup(const t_packer_opts& PackerOpts,
     }
 
     if ((false == Timing.timing_analysis_enabled)
-        && (PlacerOpts.place_algorithm == PATH_TIMING_DRIVEN_PLACE)) {
+        && (PlacerOpts.place_algorithm.is_timing_driven())) {
         /* May work, not tested */
         VPR_FATAL_ERROR(VPR_ERROR_OTHER,
                         "Timing analysis must be enabled for timing-driven placement.\n");

vpr/src/base/SetupVPR.cpp

@@ -533,6 +533,7 @@ static void SetupPlacerOpts(const t_options& Options, t_placer_opts* PlacerOpts)
     PlacerOpts->td_place_exp_last = Options.place_exp_last;
 
     PlacerOpts->place_algorithm = Options.PlaceAlgorithm;
+    PlacerOpts->place_quench_algorithm = Options.PlaceQuenchAlgorithm;
 
     PlacerOpts->constraints_file = Options.constraints_file;
 

vpr/src/base/ShowSetup.cpp

@@ -499,12 +499,15 @@ static void ShowPlacerOpts(const t_placer_opts& PlacerOpts,
     if ((PLACE_ONCE == PlacerOpts.place_freq)
         || (PLACE_ALWAYS == PlacerOpts.place_freq)) {
         VTR_LOG("PlacerOpts.place_algorithm: ");
-        switch (PlacerOpts.place_algorithm) {
+        switch (PlacerOpts.place_algorithm.get()) {
             case BOUNDING_BOX_PLACE:
                 VTR_LOG("BOUNDING_BOX_PLACE\n");
                 break;
-            case PATH_TIMING_DRIVEN_PLACE:
-                VTR_LOG("PATH_TIMING_DRIVEN_PLACE\n");
+            case CRITICALITY_TIMING_PLACE:
+                VTR_LOG("CRITICALITY_TIMING_PLACE\n");
+                break;
+            case SLACK_TIMING_PLACE:
+                VTR_LOG("SLACK_TIMING_PLACE\n");
                 break;
             default:
                 VTR_LOG_ERROR("Unknown placement algorithm\n");
@@ -533,7 +536,7 @@ static void ShowPlacerOpts(const t_placer_opts& PlacerOpts,
 
         VTR_LOG("PlacerOpts.place_chan_width: %d\n", PlacerOpts.place_chan_width);
 
-        if (PATH_TIMING_DRIVEN_PLACE == PlacerOpts.place_algorithm) {
+        if (PlacerOpts.place_algorithm.is_timing_driven()) {
             VTR_LOG("PlacerOpts.inner_loop_recompute_divider: %d\n", PlacerOpts.inner_loop_recompute_divider);
             VTR_LOG("PlacerOpts.recompute_crit_iter: %d\n", PlacerOpts.recompute_crit_iter);
             VTR_LOG("PlacerOpts.timing_tradeoff: %f\n", PlacerOpts.timing_tradeoff);

vpr/src/base/read_options.cpp

@@ -350,31 +350,35 @@ struct ParsePlaceDeltaDelayAlgorithm {
 struct ParsePlaceAlgorithm {
     ConvertedValue<e_place_algorithm> from_str(std::string str) {
         ConvertedValue<e_place_algorithm> conv_value;
-        if (str == "bounding_box")
+        if (str == "bounding_box") {
             conv_value.set_value(BOUNDING_BOX_PLACE);
-        else if (str == "path_timing_driven")
-            conv_value.set_value(PATH_TIMING_DRIVEN_PLACE);
-        else {
+        } else if (str == "criticality_timing") {
+            conv_value.set_value(CRITICALITY_TIMING_PLACE);
+        } else if (str == "slack_timing") {
+            conv_value.set_value(SLACK_TIMING_PLACE);
+        } else {
             std::stringstream msg;
-            msg << "Invalid conversion from '" << str << "' to e_router_algorithm (expected one of: " << argparse::join(default_choices(), ", ") << ")";
+            msg << "Invalid conversion from '" << str << "' to e_place_algorithm (expected one of: " << argparse::join(default_choices(), ", ") << ")";
             conv_value.set_error(msg.str());
         }
         return conv_value;
     }
 
     ConvertedValue<std::string> to_str(e_place_algorithm val) {
         ConvertedValue<std::string> conv_value;
-        if (val == BOUNDING_BOX_PLACE)
+        if (val == BOUNDING_BOX_PLACE) {
             conv_value.set_value("bounding_box");
-        else {
-            VTR_ASSERT(val == PATH_TIMING_DRIVEN_PLACE);
-            conv_value.set_value("path_timing_driven");
+        } else if (val == CRITICALITY_TIMING_PLACE) {
+            conv_value.set_value("criticality_timing");
+        } else {
+            VTR_ASSERT(val == SLACK_TIMING_PLACE);
+            conv_value.set_value("slack_timing");
         }
         return conv_value;
     }
 
     std::vector<std::string> default_choices() {
-        return {"bounding_box", "path_timing_driven"};
+        return {"bounding_box", "criticality_timing", "slack_timing"};
     }
 };
 
@@ -1679,9 +1683,23 @@ argparse::ArgumentParser create_arg_parser(std::string prog_name, t_options& arg
         .show_in(argparse::ShowIn::HELP_ONLY);
 
     place_grp.add_argument<e_place_algorithm, ParsePlaceAlgorithm>(args.PlaceAlgorithm, "--place_algorithm")
-        .help("Controls which placement algorithm is used")
-        .default_value("path_timing_driven")
-        .choices({"bounding_box", "path_timing_driven"})
+        .help(
+            "Controls which placement algorithm is used. Valid options:\n"
+            " * bounding_box: Focuses purely on minimizing the bounding box wirelength of the circuit. Turns off timing analysis if specified.\n"
+            " * criticality_timing: Focuses on minimizing both the wirelength and the connection timing costs (criticality * delay).\n"
+            " * slack_timing: Focuses on improving the circuit slack values to reduce critical path delay.\n")
+        .default_value("criticality_timing")
+        .choices({"bounding_box", "criticality_timing", "slack_timing"})
+        .show_in(argparse::ShowIn::HELP_ONLY);
+
+    place_grp.add_argument<e_place_algorithm, ParsePlaceAlgorithm>(args.PlaceQuenchAlgorithm, "--place_quench_algorithm")
+        .help(
+            "Controls which placement algorithm is used during placement quench. Valid options:\n"
+            " * bounding_box: Focuses purely on minimizing the bounding box wirelength of the circuit. Turns off timing analysis if specified.\n"
+            " * criticality_timing: Focuses on minimizing both the wirelength and the connection timing costs (criticality * delay).\n"
+            " * slack_timing: Focuses on improving the circuit slack values to reduce critical path delay.\n")
+        .default_value("criticality_timing")
+        .choices({"bounding_box", "criticality_timing", "slack_timing"})
         .show_in(argparse::ShowIn::HELP_ONLY);
 
     place_grp.add_argument(args.PlaceChanWidth, "--place_chan_width")
@@ -2306,12 +2324,17 @@ void set_conditional_defaults(t_options& args) {
     //Which placement algorithm to use?
     if (args.PlaceAlgorithm.provenance() != Provenance::SPECIFIED) {
         if (args.timing_analysis) {
-            args.PlaceAlgorithm.set(PATH_TIMING_DRIVEN_PLACE, Provenance::INFERRED);
+            args.PlaceAlgorithm.set(CRITICALITY_TIMING_PLACE, Provenance::INFERRED);
         } else {
             args.PlaceAlgorithm.set(BOUNDING_BOX_PLACE, Provenance::INFERRED);
         }
     }
 
+    //Which placement algorithm to use during placement quench?
+    if (args.PlaceQuenchAlgorithm.provenance() != Provenance::SPECIFIED) {
+        args.PlaceQuenchAlgorithm.set(args.PlaceAlgorithm, Provenance::INFERRED);
+    }
+
     //Place chan width follows Route chan width if unspecified
     if (args.PlaceChanWidth.provenance() != Provenance::SPECIFIED && args.RouteChanWidth.provenance() == Provenance::SPECIFIED) {
         args.PlaceChanWidth.set(args.RouteChanWidth.value(), Provenance::INFERRED);

vpr/src/base/read_options.h

@@ -104,6 +104,7 @@ struct t_options {
     argparse::ArgValue<float> PlaceSuccessTarget;
     argparse::ArgValue<sched_type> anneal_sched_type;
     argparse::ArgValue<e_place_algorithm> PlaceAlgorithm;
+    argparse::ArgValue<e_place_algorithm> PlaceQuenchAlgorithm;
     argparse::ArgValue<e_pad_loc_type> pad_loc_type;
     argparse::ArgValue<int> PlaceChanWidth;
     argparse::ArgValue<float> place_rlim_escape_fraction;

vpr/src/base/vpr_types.h

@@ -829,36 +829,84 @@ struct t_annealing_sched {
     float success_target;
 };
 
-/* Various options for the placer.                                           *
- * place_algorithm:  BOUNDING_BOX_PLACE or PATH_TIMING_DRIVEN_PLACE          *
- * timing_tradeoff:  When TIMING_DRIVEN_PLACE mode, what is the tradeoff     *
- *                   timing driven and BOUNDING_BOX_PLACE.                   *
- * place_cost_exp:  Power to which denominator is raised for linear_cong.    *
- * place_chan_width:  The channel width assumed if only one placement is     *
- *                    performed.                                             *
- * pad_loc_type:  Are pins free to move during placement or fixed randomly.  *
- * constraints_file:  File used to lock block locations during placement.    *
- * place_freq:  Should the placement be skipped, done once, or done for each *
- *              channel width in the binary search.                          *
- * recompute_crit_iter: how many temperature stages pass before we recompute *
- *               criticalities based on average point to point delay         *
- * inner_loop_crit_divider: (move_lim/inner_loop_crit_divider) determines how*
- *               many inner_loop iterations pass before a recompute of       *
- *               criticalities is done.                                      *
- * td_place_exp_first: exponent that is used on the timing_driven criticlity *
- *               it is the value that the exponent starts at.                *
- * td_place_exp_last: value that the criticality exponent will be at the end *
- * doPlacement: true if placement is supposed to be done in the CAD flow, false otherwise */
+/******************************************************************
+ * Placer data types
+ *******************************************************************/
+
+/**
+ * @brief Types of placement algorithms used in the placer.
+ *
+ *   @param BOUNDING_BOX_PLACE
+ *              Focuses purely on minimizing the bounding
+ *              box wirelength of the circuit.
+ *   @param CRITICALITY_TIMING_PLACE
+ *              Focuses on minimizing both the wirelength and the
+ *              connection timing costs (criticality * delay).
+ *   @param SLACK_TIMING_PLACE
+ *              Focuses on improving the circuit slack values
+ *              to reduce critical path delay.
+ *
+ * The default is to use CRITICALITY_TIMING_PLACE. BOUNDING_BOX_PLACE
+ * is used when there is no timing information available (wiring only).
+ * SLACK_TIMING_PLACE is mainly feasible during placement quench.
+ */
 enum e_place_algorithm {
     BOUNDING_BOX_PLACE,
-    PATH_TIMING_DRIVEN_PLACE
+    CRITICALITY_TIMING_PLACE,
+    SLACK_TIMING_PLACE
+};
+
+/**
+ * @brief Provides a wrapper around enum e_place_algorithm.
+ *
+ * Supports the method isTimingDriven(), which allows flexible updates
+ * to the placer algorithms if more timing driven placement strategies
+ * are added in tht future. This method is used across various placement
+ * setup files, and it can be useful for major placer routines as well.
+ *
+ * More methods can be added to this class if the placement strategies
+ * will be further divided into more categories the future.
+ *
+ * Also supports assignments and comparisons between t_place_algorithm
+ * and e_place_algorithm so as not to break down previous codes.
+ */
+class t_place_algorithm {
+  public:
+    //Constructors
+    t_place_algorithm() = default;
+    t_place_algorithm(e_place_algorithm _algo)
+        : algo(_algo) {}
+    ~t_place_algorithm() = default;
+
+    //Assignment operators
+    void operator=(const t_place_algorithm& rhs) { algo = rhs.algo; }
+    void operator=(e_place_algorithm rhs) { algo = rhs; }
+
+    //Equality operators
+    bool operator==(const t_place_algorithm& rhs) const { return algo == rhs.algo; }
+    bool operator==(e_place_algorithm rhs) const { return algo == rhs; }
+    bool operator!=(const t_place_algorithm& rhs) const { return algo != rhs.algo; }
+    bool operator!=(e_place_algorithm rhs) const { return algo != rhs; }
+
+    ///@brief Check if the algorithm belongs to the timing driven category.
+    inline bool is_timing_driven() const {
+        return algo == CRITICALITY_TIMING_PLACE || algo == SLACK_TIMING_PLACE;
+    }
+
+    ///@brief Accessor: returns the underlying e_place_algorithm enum value.
+    e_place_algorithm get() const { return algo; }
+
+  private:
+    ///@brief The underlying algorithm. Default set to CRITICALITY_TIMING_PLACE.
+    e_place_algorithm algo = e_place_algorithm::CRITICALITY_TIMING_PLACE;
 };
 
 enum e_pad_loc_type {
     FREE,
     RANDOM
 };
 
+///@brief Used to calculate the inner placer loop's block swapping limit move_lim.
 enum e_place_effort_scaling {
     CIRCUIT,       ///<Effort scales based on circuit size only
     DEVICE_CIRCUIT ///<Effort scales based on both circuit and device size
@@ -889,8 +937,51 @@ enum class e_place_delta_delay_algorithm {
     DIJKSTRA_EXPANSION,
 };
 
+/**
+ * @brief Various options for the placer.
+ *
+ *   @param place_algorithm
+ *              Controls which placement algorithm is used.
+ *   @param place_quench_algorithm
+ *              Controls which placement algorithm is used
+ *              during placement quench.
+ *   @param timing_tradeoff
+ *              When in CRITICALITY_TIMING_PLACE mode, what is the
+ *              tradeoff between timing and wiring costs.
+ *   @param place_cost_exp
+ *              Power to which denominator is raised for linear_cong.
+ *   @param place_chan_width
+ *              The channel width assumed if only one placement is performed.
+ *   @param pad_loc_type
+ *              Are pins FREE, fixed randomly, or fixed from a file.
+ *   @param block_loc_type
+ *              Are blocks fixed from a file.
+ *   @param constraints_file
+ *              File to read block locations from if block_loc_type is LOCKED.
+ *   @param pad_loc_file
+ *              File to read pad locations from if pad_loc_type is USER.
+ *   @param place_freq
+ *              Should the placement be skipped, done once, or done
+ *              for each channel width in the binary search.
+ *   @param recompute_crit_iter
+ *              How many temperature stages pass before we recompute
+ *              criticalities based on average point to point delay.
+ *   @param inner_loop_crit_divider
+ *              (move_lim/inner_loop_crit_divider) determines how
+ *              many inner_loop iterations pass before a recompute
+ *              of criticalities is done.
+ *   @param td_place_exp_first
+ *              Exponent that is used in the CRITICALITY_TIMING_PLACE
+ *              mode. It is the value that the crit_exponent starts at.
+ *   @param td_place_exp_last
+ *              Value that the criticality exponent will be at the end.
+ *   @param doPlacement
+ *              True if placement is supposed to be done in the CAD flow.
+ *              False if otherwise.
+ */
 struct t_placer_opts {
-    enum e_place_algorithm place_algorithm;
+    t_place_algorithm place_algorithm;
+    t_place_algorithm place_quench_algorithm;
     float timing_tradeoff;
     float place_cost_exp;
     int place_chan_width;