Merge pull request #3154 from AlexandreSinger/feature-ap-global-nets

[AP] Marking Global Nets in AP

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.