Merge pull request #3086 from AlexandreSinger/feature-ap-timing

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

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_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.generate_mass_report,
                                                                          ap_opts.num_threads,
@@ -182,13 +192,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,38 @@ 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_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_);
+
+        // When optimizing for WL, the net weights are just set to 1 (meaning
+        // that we want to minimize the WL of nets).
+        // When optimizing for timing, the net weights are set to the timing
+        // criticality, which is based on the lowest slack of any edge belonging
+        // to this net.
+        // The intuition is that we care more about shrinking the wirelength of
+        // more critical connections than less critical ones.
+        // Use the AP timing trade-off term to linearly interpolate between these
+        // weighting terms.
+        net_weights_[net_id] = ap_timing_tradeoff_ * crit + (1.0f - ap_timing_tradeoff_);
     }
 }
 
@@ -225,7 +246,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_ignored(net_id))
+            continue;
+        num_nets++;
         if (netlist_.net_pins(net_id).size() > star_num_pins_threshold)
             num_star_nodes++;
     }
@@ -248,13 +273,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_ignored(net_id))
+            continue;
         size_t num_pins = netlist_.net_pins(net_id).size();
         VTR_ASSERT_DEBUG(num_pins > 1);
 
@@ -772,6 +798,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_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_;
 };