[AP][Timing] Used Flat Placement Info to Compute Setup Criticalities

When timing analysis was turned on for AP, we originally only used the
pre-cluster timing analyzer which was very high-level and innacurate. It
practically just counted the number of hops between launch and capture
registers to approximate criticality.

Improved this by using flat placement information provided by AP.

During global placement, the criticality of all edges are recomputed
using the upper bound solution from the prior iteration of GP. The place
delay model from the placement flow was used to get an mostly-accurate
delay estimation for distances between tiles. The slacks computed each
GP iteration are used to update the net weights between iterations to
better optimize CPD and sTNS.

This improved estimation of setup slacks is then passed into the full
legalizer, which it is then used by the packer to better pack critical
atoms together.

This change required some changes to the APNetlist. Notably, we need all
atom nets to be located somewhere in the AP netlist such that their
delays can be calculated properly. Instead of removing nets we do not
care about for AP, marked them as ignored.

Author: AlexandreSinger

vpr/src/analytical_place/analytical_placement_flow.cpp

@@ -7,6 +7,7 @@
 
 #include "analytical_placement_flow.h"
 #include <memory>
+#include "PlacementDelayModelCreator.h"
 #include "PreClusterTimingManager.h"
 #include "analytical_solver.h"
 #include "ap_netlist.h"
@@ -17,8 +18,11 @@
 #include "gen_ap_netlist_from_atoms.h"
 #include "global_placer.h"
 #include "globals.h"
+#include "netlist_fwd.h"
 #include "partial_legalizer.h"
 #include "partial_placement.h"
+#include "physical_types.h"
+#include "place_delay_model.h"
 #include "prepack.h"
 #include "user_place_constraints.h"
 #include "vpr_context.h"
@@ -43,19 +47,23 @@ static void print_ap_netlist_stats(const APNetlist& netlist) {
     // Get the fanout information of nets
     size_t highest_fanout = 0;
     float average_fanout = 0.f;
+    unsigned net_count = 0;
     for (APNetId net_id : netlist.nets()) {
+        if (netlist.net_is_global(net_id) || netlist.net_is_ignored(net_id))
+            continue;
         size_t net_fanout = netlist.net_pins(net_id).size();
         if (net_fanout > highest_fanout)
             highest_fanout = net_fanout;
         average_fanout += static_cast<float>(net_fanout);
+        net_count++;
     }
-    average_fanout /= static_cast<float>(netlist.nets().size());
+    average_fanout /= static_cast<float>(net_count);
     // Print the statistics
     VTR_LOG("Analytical Placement Netlist Statistics:\n");
     VTR_LOG("\tBlocks: %zu\n", netlist.blocks().size());
     VTR_LOG("\t\tMoveable Blocks: %zu\n", num_moveable_blocks);
     VTR_LOG("\t\tFixed Blocks: %zu\n", num_fixed_blocks);
-    VTR_LOG("\tNets: %zu\n", netlist.nets().size());
+    VTR_LOG("\tNets: %zu\n", net_count);
     VTR_LOG("\t\tAverage Fanout: %.2f\n", average_fanout);
     VTR_LOG("\t\tHighest Fanout: %zu\n", highest_fanout);
     VTR_LOG("\tPins: %zu\n", netlist.pins().size());
@@ -122,7 +130,8 @@ static PartialPlacement run_global_placer(const t_ap_opts& ap_opts,
                                           const AtomNetlist& atom_nlist,
                                           const APNetlist& ap_netlist,
                                           const Prepacker& prepacker,
-                                          const PreClusterTimingManager& pre_cluster_timing_manager,
+                                          PreClusterTimingManager& pre_cluster_timing_manager,
+                                          std::shared_ptr<PlaceDelayModel> place_delay_model,
                                           const DeviceContext& device_ctx) {
     if (g_vpr_ctx.atom().flat_placement_info().valid) {
         VTR_LOG("Flat Placement is provided in the AP flow, skipping the Global Placement.\n");
@@ -143,6 +152,7 @@ static PartialPlacement run_global_placer(const t_ap_opts& ap_opts,
                                                                          device_ctx.logical_block_types,
                                                                          device_ctx.physical_tile_types,
                                                                          pre_cluster_timing_manager,
+                                                                         place_delay_model,
                                                                          ap_opts.ap_timing_tradeoff,
                                                                          ap_opts.num_threads,
                                                                          ap_opts.log_verbosity);
@@ -181,13 +191,28 @@ void run_analytical_placement_flow(t_vpr_setup& vpr_setup) {
                                                        vpr_setup.PackerOpts.device_layout,
                                                        vpr_setup.AnalysisOpts);
 
+    // Pre-compute the place delay model. This will be passed into the global
+    // placer to create a more accurate timing model.
+    std::shared_ptr<PlaceDelayModel> place_delay_model;
+    if (pre_cluster_timing_manager.is_valid()) {
+        place_delay_model = PlacementDelayModelCreator::create_delay_model(vpr_setup.PlacerOpts,
+                                                                           vpr_setup.RouterOpts,
+                                                                           (const Netlist<>&)atom_nlist,
+                                                                           vpr_setup.RoutingArch,
+                                                                           vpr_setup.Segments,
+                                                                           device_ctx.arch->Chans,
+                                                                           device_ctx.arch->directs,
+                                                                           false /*is_flat*/);
+    }
+
     // Run the Global Placer.
     const t_ap_opts& ap_opts = vpr_setup.APOpts;
     PartialPlacement p_placement = run_global_placer(ap_opts,
                                                      atom_nlist,
                                                      ap_netlist,
                                                      prepacker,
                                                      pre_cluster_timing_manager,
+                                                     place_delay_model,
                                                      device_ctx);
 
     // Verify that the partial placement is valid before running the full

vpr/src/analytical_place/analytical_solver.cpp

@@ -114,9 +114,11 @@ AnalyticalSolver::AnalyticalSolver(const APNetlist& netlist,
                                    float ap_timing_tradeoff,
                                    int log_verbosity)
     : netlist_(netlist)
+    , atom_netlist_(atom_netlist)
     , blk_id_to_row_id_(netlist.blocks().size(), APRowId::INVALID())
     , row_id_to_blk_id_(netlist.blocks().size(), APBlockId::INVALID())
     , net_weights_(netlist.nets().size(), 1.0f)
+    , ap_timing_tradeoff_(ap_timing_tradeoff)
     , log_verbosity_(log_verbosity) {
     // Get the number of moveable blocks in the netlist and create a unique
     // row ID from [0, num_moveable_blocks) for each moveable block in the
@@ -136,19 +138,29 @@ AnalyticalSolver::AnalyticalSolver(const APNetlist& netlist,
         num_moveable_blocks_++;
     }
 
-    if (pre_cluster_timing_manager.is_valid()) {
-        for (APNetId net_id : netlist.nets()) {
-            // Get the atom net associated with the given AP net. When
-            // constructing the AP netlist, we happen to set the name of each
-            // AP net to the same name as the atom net that generated them!
-            // TODO: Create a proper lookup structure to go from the AP Netlist
-            //       back to the Atom Netlist.
-            AtomNetId atom_net_id = atom_netlist.find_net(netlist.net_name(net_id));
-            VTR_ASSERT(atom_net_id.is_valid());
-            float crit = pre_cluster_timing_manager.calc_net_setup_criticality(atom_net_id, atom_netlist);
-
-            net_weights_[net_id] = ap_timing_tradeoff * crit + (1.0f - ap_timing_tradeoff);
-        }
+    update_net_weights(pre_cluster_timing_manager);
+}
+
+void AnalyticalSolver::update_net_weights(const PreClusterTimingManager& pre_cluster_timing_manager) {
+    // If the pre-cluster timing manager has not been initialized (i.e. timing
+    // analysis is off), no need to update.
+    if (!pre_cluster_timing_manager.is_valid())
+        return;
+
+    // For each of the nets, update the net weights.
+    for (APNetId net_id : netlist_.nets()) {
+        // Note: To save time, we do not compute the weights of nets that we
+        //       do not care about for AP. This leaves their weights at 1.0 just
+        //       in case they are accidentally used.
+        if (netlist_.net_is_global(net_id) || netlist_.net_is_ignored(net_id))
+            continue;
+
+        AtomNetId atom_net_id = netlist_.net_atom_net(net_id);
+        VTR_ASSERT_SAFE(atom_net_id.is_valid());
+
+        float crit = pre_cluster_timing_manager.calc_net_setup_criticality(atom_net_id, atom_netlist_);
+
+        net_weights_[net_id] = ap_timing_tradeoff_ * crit + (1.0f - ap_timing_tradeoff_);
     }
 }
 
@@ -225,7 +237,11 @@ static inline void add_connection_to_system(size_t src_row_id,
 void QPHybridSolver::init_linear_system() {
     // Count the number of star nodes that the netlist will have.
     size_t num_star_nodes = 0;
+    unsigned num_nets = 0;
     for (APNetId net_id : netlist_.nets()) {
+        if (netlist_.net_is_global(net_id) || netlist_.net_is_ignored(net_id))
+            continue;
+        num_nets++;
         if (netlist_.net_pins(net_id).size() > star_num_pins_threshold)
             num_star_nodes++;
     }
@@ -248,13 +264,14 @@ void QPHybridSolver::init_linear_system() {
     // TODO: This can be made more space-efficient by getting the average fanout
     //       of all nets in the APNetlist. Ideally this should be not enough
     //       space, but be within a constant factor.
-    size_t num_nets = netlist_.nets().size();
     tripletList.reserve(num_nets);
 
     // Create the connections using a hybrid connection model of the star and
     // clique connnection models.
     size_t star_node_offset = 0;
     for (APNetId net_id : netlist_.nets()) {
+        if (netlist_.net_is_global(net_id) || netlist_.net_is_ignored(net_id))
+            continue;
         size_t num_pins = netlist_.net_pins(net_id).size();
         VTR_ASSERT_DEBUG(num_pins > 1);
 
@@ -772,6 +789,8 @@ void B2BSolver::init_linear_system(PartialPlacement& p_placement) {
     triplet_list_y.reserve(num_nets);
 
     for (APNetId net_id : netlist_.nets()) {
+        if (netlist_.net_is_global(net_id) || netlist_.net_is_ignored(net_id))
+            continue;
         size_t num_pins = netlist_.net_pins(net_id).size();
         VTR_ASSERT_SAFE_MSG(num_pins > 1, "net must have at least 2 pins");
 

vpr/src/analytical_place/analytical_solver.h

@@ -95,11 +95,24 @@ class AnalyticalSolver {
      */
     virtual void print_statistics() = 0;
 
+    /**
+     * @brief Update the net weights according to the criticality of the nets.
+     *
+     *  @param pre_cluster_timing_manager
+     *      The timing manager which manages the criticalities of the nets.
+     */
+    void update_net_weights(const PreClusterTimingManager& pre_cluster_timing_manager);
+
   protected:
     /// @brief The APNetlist the solver is optimizing over. It is implied that
     ///        the netlist is not being modified during global placement.
     const APNetlist& netlist_;
 
+    /// @brief The Atom netlist the solver is optimizing over. It is implied
+    ///        that the atom netlist is not being modified during global
+    ///        placement.
+    const AtomNetlist& atom_netlist_;
+
     /// @brief The number of moveable blocks in the netlist. This is helpful
     ///        when allocating matrices.
     size_t num_moveable_blocks_ = 0;
@@ -124,6 +137,10 @@ class AnalyticalSolver {
     ///        between 0 and 1.
     vtr::vector<APNetId, float> net_weights_;
 
+    /// @brief The AP timing tradeoff term used during global placement. Decides
+    ///        how much the solver cares about timing vs wirelength.
+    float ap_timing_tradeoff_;
+
     /// @brief The verbosity of log messages in the Analytical Solver.
     int log_verbosity_;
 };

vpr/src/analytical_place/ap_netlist.cpp

@@ -7,6 +7,7 @@
 
 #include "ap_netlist.h"
 #include <string>
+#include "atom_netlist_fwd.h"
 #include "netlist_fwd.h"
 #include "netlist_utils.h"
 #include "prepack.h"
@@ -34,6 +35,24 @@ const APFixedBlockLoc& APNetlist::block_loc(const APBlockId id) const {
     return block_locs_[id];
 }
 
+/*
+ * Pins
+ */
+AtomPinId APNetlist::pin_atom_pin(const APPinId id) const {
+    VTR_ASSERT_SAFE(valid_pin_id(id));
+
+    return pin_atom_pin_[id];
+}
+
+/*
+ * Nets
+ */
+AtomNetId APNetlist::net_atom_net(const APNetId id) const {
+    VTR_ASSERT_SAFE(valid_net_id(id));
+
+    return net_atom_net_[id];
+}
+
 /*
  * Mutators
  */
@@ -93,9 +112,12 @@ APPortId APNetlist::create_port(const APBlockId blk_id, const std::string& name,
     return port_id;
 }
 
-APPinId APNetlist::create_pin(const APPortId port_id, BitIndex port_bit, const APNetId net_id, const PinType pin_type_, bool is_const) {
+APPinId APNetlist::create_pin(const APPortId port_id, BitIndex port_bit, const APNetId net_id, const PinType pin_type_, const AtomPinId atom_pin_id, bool is_const) {
     APPinId pin_id = Netlist::create_pin(port_id, port_bit, net_id, pin_type_, is_const);
 
+    // Initialize the pin data.
+    pin_atom_pin_.insert(pin_id, atom_pin_id);
+
     // Check post-conditions: size
     VTR_ASSERT(validate_pin_sizes());
 
@@ -107,9 +129,12 @@ APPinId APNetlist::create_pin(const APPortId port_id, BitIndex port_bit, const A
     return pin_id;
 }
 
-APNetId APNetlist::create_net(const std::string& name) {
+APNetId APNetlist::create_net(const std::string& name, const AtomNetId atom_net_id) {
     APNetId net_id = Netlist::create_net(name);
 
+    // Initialize the net data.
+    net_atom_net_.insert(net_id, atom_net_id);
+
     // Check post-conditions: size
     VTR_ASSERT(validate_net_sizes());
 
@@ -132,12 +157,12 @@ void APNetlist::clean_ports_impl(const vtr::vector_map<APPortId, APPortId>& /*po
     // Unused
 }
 
-void APNetlist::clean_pins_impl(const vtr::vector_map<APPinId, APPinId>& /*pin_id_map*/) {
-    // Unused
+void APNetlist::clean_pins_impl(const vtr::vector_map<APPinId, APPinId>& pin_id_map) {
+    pin_atom_pin_ = clean_and_reorder_values(pin_atom_pin_, pin_id_map);
 }
 
-void APNetlist::clean_nets_impl(const vtr::vector_map<APNetId, APNetId>& /*net_id_map*/) {
-    // Unused
+void APNetlist::clean_nets_impl(const vtr::vector_map<APNetId, APNetId>& net_id_map) {
+    net_atom_net_ = clean_and_reorder_values(net_atom_net_, net_id_map);
 }
 
 void APNetlist::rebuild_block_refs_impl(const vtr::vector_map<APPinId, APPinId>& /*pin_id_map*/,
@@ -162,6 +187,12 @@ void APNetlist::shrink_to_fit_impl() {
     block_molecules_.shrink_to_fit();
     block_mobilities_.shrink_to_fit();
     block_locs_.shrink_to_fit();
+
+    // Pin data
+    pin_atom_pin_.shrink_to_fit();
+
+    // Net data
+    net_atom_net_.shrink_to_fit();
 }
 
 void APNetlist::remove_block_impl(const APBlockId /*blk_id*/) {
@@ -198,12 +229,14 @@ bool APNetlist::validate_port_sizes_impl(size_t /*num_ports*/) const {
     return true;
 }
 
-bool APNetlist::validate_pin_sizes_impl(size_t /*num_pins*/) const {
-    // No AP-specific pin data to check
+bool APNetlist::validate_pin_sizes_impl(size_t num_pins) const {
+    if (pin_atom_pin_.size() != num_pins)
+        return false;
     return true;
 }
 
-bool APNetlist::validate_net_sizes_impl(size_t /*num_nets*/) const {
-    // No AP-specific net data to check
+bool APNetlist::validate_net_sizes_impl(size_t num_nets) const {
+    if (net_atom_net_.size() != num_nets)
+        return false;
     return true;
 }

vpr/src/analytical_place/ap_netlist.h

@@ -20,6 +20,7 @@
  */
 
 #include <string>
+#include "atom_netlist_fwd.h"
 #include "netlist.h"
 #include "ap_netlist_fwd.h"
 #include "prepack.h"
@@ -90,6 +91,20 @@ class APNetlist : public Netlist<APBlockId, APPortId, APPinId, APNetId> {
     ///        This method should not be used if the block is moveable.
     const APFixedBlockLoc& block_loc(const APBlockId id) const;
 
+    /*
+     * Pins
+     */
+
+    /// @brief Returns the atom pin that corresponds with the given AP pin.
+    AtomPinId pin_atom_pin(const APPinId id) const;
+
+    /*
+     * Nets
+     */
+
+    /// @brief Returns the atom net that corresponds with the given AP net.
+    AtomNetId net_atom_net(const APNetId id) const;
+
   public: // Public Mutators
     /*
      * Note: all create_*() functions will silently return the appropriate ID
@@ -129,17 +144,19 @@ class APNetlist : public Netlist<APBlockId, APPortId, APPinId, APNetId> {
      *  @param port_bit The bit index of the pin in the port
      *  @param net_id   The net the pin drives/sinks
      *  @param pin_type The type of the pin (driver/sink)
+     *  @param atom_pin_id The atom pin that this pin is modeling.
      *  @param is_const Indicates whether the pin holds a constant value (e.g.
      *                  vcc/gnd)
      */
-    APPinId create_pin(const APPortId port_id, BitIndex port_bit, const APNetId net_id, const PinType pin_type, bool is_const = false);
+    APPinId create_pin(const APPortId port_id, BitIndex port_bit, const APNetId net_id, const PinType pin_type, const AtomPinId atom_pin_id, bool is_const = false);
 
     /**
      * @brief Create an empty, or return an existing net in the netlist
      *
      *  @param name The unique name of the net
+     *  @param atom_net_id The atom net that this net is modeling.
      */
-    APNetId create_net(const std::string& name);
+    APNetId create_net(const std::string& name, const AtomNetId atom_net_id);
 
   private: // Private Members
     /*
@@ -186,4 +203,8 @@ class APNetlist : public Netlist<APBlockId, APPortId, APPinId, APNetId> {
     /// @brief Location of each block (if fixed).
     ///        NOTE: This vector will likely be quite sparse.
     vtr::vector_map<APBlockId, APFixedBlockLoc> block_locs_;
+    /// @brief Atom pin associated with each AP pin.
+    vtr::vector_map<APPinId, AtomPinId> pin_atom_pin_;
+    /// @brief Atom net associated with each AP net.
+    vtr::vector_map<APNetId, AtomNetId> net_atom_net_;
 };