[AP] Marking Global Nets in AP

After investigating how the placer and packer decide which nets are
global, I realized that we were not marking any nets as global. The Atom
Netlist annotates nets as global after packing, when loading the
clustered netlist. It decides if a net is global or not if the net
enters a global port in the clustered netlist.

We can replicate this behaviour during AP by looking at the Atom Netlist
and doing something similar. This allows us to tell if a net is global
or not.

In AP, we always want to ignore global nets since their cost does not
play a role on the overall objective. By ignoring these nets, we can
further improve the performance and quality of the solution.

Now that we know which nets are global, I have also updated the
wirelength estimator in the AP flow to make it align better with the
placer's wirelength estimator. They now line up very closely, but are
still slightly off due to some factors being unable to be ported over
easily.

Author: AlexandreSinger

vpr/src/analytical_place/gen_ap_netlist_from_atoms.cpp

@@ -126,13 +126,38 @@ APNetlist gen_ap_netlist_from_atoms(const AtomNetlist& atom_netlist,
             ap_netlist.set_net_is_ignored(ap_net_id, true);
             continue;
         }
+
         // Is the net global, if so mark as global for AP (also ignored)
         if (atom_netlist.net_is_global(atom_net_id)) {
             ap_netlist.set_net_is_global(ap_net_id, true);
             // Global nets are also ignored by the AP flow.
             ap_netlist.set_net_is_ignored(ap_net_id, true);
             continue;
         }
+
+        // Prior to AP, it is likely that the nets in the Atom Netlist have not
+        // been annotated with being global or ignored. To get around this, we
+        // annotate the AP Netlist speculatively.
+        // We label a net as being global if one of its pin connect to a clock
+        // port or a non-clock global model port.
+        bool is_global = false;
+        for (AtomPinId pin_id : atom_netlist.net_pins(atom_net_id)) {
+            AtomPortId port_id = atom_netlist.pin_port(pin_id);
+            if (atom_netlist.port_type(port_id) == PortType::CLOCK) {
+                is_global = true;
+                break;
+            }
+            if (atom_netlist.port_model(port_id)->is_non_clock_global) {
+                is_global = true;
+                break;
+            }
+        }
+        if (is_global) {
+            ap_netlist.set_net_is_global(ap_net_id, true);
+            // Global nets are also ignored in the AP flow.
+            ap_netlist.set_net_is_ignored(ap_net_id, true);
+        }
+
         // Get the unique blocks connectioned to this net
         std::unordered_set<APBlockId> net_blocks;
         for (APPinId ap_pin_id : ap_netlist.net_pins(ap_net_id)) {

vpr/src/analytical_place/global_placer.cpp

@@ -132,7 +132,7 @@ static void print_placement_stats(const PartialPlacement& p_placement,
                                   const PreClusterTimingManager& pre_cluster_timing_manager) {
     // Print the placement HPWL
     VTR_LOG("\tPlacement objective HPWL: %f\n", p_placement.get_hpwl(ap_netlist));
-    VTR_LOG("\tPlacement estimated wirelength: %u\n", p_placement.estimate_post_placement_wirelength(ap_netlist));
+    VTR_LOG("\tPlacement estimated wirelength: %g\n", p_placement.estimate_post_placement_wirelength(ap_netlist));
 
     // Print the timing information.
     if (pre_cluster_timing_manager.is_valid()) {

vpr/src/analytical_place/partial_placement.cpp

@@ -10,6 +10,7 @@
 #include <cstddef>
 #include <limits>
 #include "ap_netlist.h"
+#include "net_cost_handler.h"
 
 double PartialPlacement::get_hpwl(const APNetlist& netlist) const {
     double hpwl = 0.0;
@@ -27,6 +28,11 @@ double PartialPlacement::get_hpwl(const APNetlist& netlist) const {
             min_y = std::min(min_y, block_y_locs[blk_id]);
             max_y = std::max(max_y, block_y_locs[blk_id]);
         }
+        // TODO: In the placer, the x and y dimensions are multiplied by cost
+        //       factors based on the channel width. Should somehow bring these
+        //       in here.
+        //       Vaughn thinks these may make sense in the objective HPWL, but
+        //       not the in the estimated post-placement wirelength.
         VTR_ASSERT_SAFE(max_x >= min_x && max_y >= min_y);
         hpwl += max_x - min_x + max_y - min_y;
     }
@@ -38,23 +44,26 @@ double PartialPlacement::estimate_post_placement_wirelength(const APNetlist& net
     // we want to estimate the post-placement wirelength, we do not want the
     // flat placement positions of the blocks. Instead we compute the HPWL over
     // the tiles that the flat placement is placing the blocks over.
-    unsigned total_hpwl = 0;
+    double total_hpwl = 0;
     for (APNetId net_id : netlist.nets()) {
-        // Note: Other wirelength estimates in VTR ignore global nets; however
-        //       it is not known if a net is global or not until packing is
-        //       complete. For now, we just approximate post-placement wirelength
-        //       using the HPWL (in tile space).
-        // TODO: The reason we do not know what nets are ignored / global is
-        //       because the pin on the tile that the net connects to is what
-        //       decides if a net is global / ignored for place and route. Since
-        //       we have not packed anything yet, we do not know what pin each
-        //       net will go to; however, we can probably get a good idea based
-        //       on some properties of the net and the tile its going to / from.
-        //       Should investigate this to get a better estimate of wirelength.
-        double min_x = std::numeric_limits<unsigned>::max();
-        double max_x = std::numeric_limits<unsigned>::lowest();
-        double min_y = std::numeric_limits<unsigned>::max();
-        double max_y = std::numeric_limits<unsigned>::lowest();
+        // To align with other wirelength estimators in VTR (for example in the
+        // placer), we do not include global nets (clocks, etc.) in the wirelength
+        // calculation.
+        if (netlist.net_is_global(net_id))
+            continue;
+
+        // Similar to the placer, weight the wirelength of this net as a function
+        // of its fanout. Since these fanouts are at the AP netlist (unclustered)
+        // level, the correction factor may lead to a somewhat higher HPWL prediction
+        // than after clustering.
+        // TODO: Investigate the clustered vs unclustered factors further.
+        // TODO: Should update the costs to 3D.
+        double crossing = wirelength_crossing_count(netlist.net_pins(net_id).size());
+
+        double min_x = std::numeric_limits<double>::max();
+        double max_x = std::numeric_limits<double>::lowest();
+        double min_y = std::numeric_limits<double>::max();
+        double max_y = std::numeric_limits<double>::lowest();
         for (APPinId pin_id : netlist.net_pins(net_id)) {
             APBlockId blk_id = netlist.pin_block(pin_id);
             min_x = std::min(min_x, block_x_locs[blk_id]);
@@ -66,10 +75,10 @@ double PartialPlacement::estimate_post_placement_wirelength(const APNetlist& net
 
         // Floor the positions to get the x and y coordinates of the tiles each
         // block belongs to.
-        unsigned tile_dx = std::floor(max_x) - std::floor(min_x);
-        unsigned tile_dy = std::floor(max_y) - std::floor(min_y);
+        double tile_dx = std::floor(max_x) - std::floor(min_x);
+        double tile_dy = std::floor(max_y) - std::floor(min_y);
 
-        total_hpwl += tile_dx + tile_dy;
+        total_hpwl += (tile_dx + tile_dy) * crossing;
     }
 
     return total_hpwl;

vpr/src/place/net_cost_handler.cpp

@@ -84,13 +84,6 @@ static void add_block_to_bb(const t_physical_tile_loc& new_pin_loc,
                             t_2D_bb& bb_edge_new,
                             t_2D_bb& bb_coord_new);
 
-/**
- * @brief To get the wirelength cost/est, BB perimeter is multiplied by a factor to approximately correct for the half-perimeter
- * bounding box wirelength's underestimate of wiring for nets with fanout greater than 2.
- * @return Multiplicative wirelength correction factor
- */
-static double wirelength_crossing_count(size_t fanout);
-
 /******************************* End of Function definitions ************************************/
 
 NetCostHandler::NetCostHandler(const t_placer_opts& placer_opts,
@@ -1492,7 +1485,7 @@ double NetCostHandler::recompute_bb_cost_() {
     return cost;
 }
 
-static double wirelength_crossing_count(size_t fanout) {
+double wirelength_crossing_count(size_t fanout) {
     /* Get the expected "crossing count" of a net, based on its number *
      * of pins.  Extrapolate for very large nets.                      */
 

vpr/src/place/net_cost_handler.h

@@ -15,6 +15,13 @@
 class PlacerState;
 class PlacerCriticalities;
 
+/**
+ * @brief To get the wirelength cost/est, BB perimeter is multiplied by a factor to approximately correct for the half-perimeter
+ * bounding box wirelength's underestimate of wiring for nets with fanout greater than 2.
+ * @return Multiplicative wirelength correction factor
+ */
+double wirelength_crossing_count(size_t fanout);
+
 /**
  * @brief The method used to calculate placement cost
  * @details For comp_cost. NORMAL means use the method that generates updatable bounding boxes for speed.