remove functionally redundant parts via mass ablation

Author: WilliamZhang20

vpr/src/analytical_place/global_placement/affinity_spring_term.cpp

@@ -12,29 +12,13 @@
 using vtr::ap::affinity_spring_curvature;
 
 AffinitySpringTerm::AffinitySpringTerm(const APNetlist& ap_netlist,
-                                       double io_pair_attraction_weight,
                                        double pack_pattern_weight)
-    : io_pair_attraction_weight_(io_pair_attraction_weight)
-    , pack_pattern_weight_(pack_pattern_weight)
+    : pack_pattern_weight_(pack_pattern_weight)
     , moveable_(ap_netlist.blocks().size(), false) {
     for (APBlockId blk_id : ap_netlist.blocks())
         moveable_[blk_id] = ap_netlist.block_mobility(blk_id) == APBlockMobility::MOVEABLE;
 }
 
-double AffinitySpringTerm::kernel_weight_(e_affinity_kind kind) const {
-    switch (kind) {
-        case e_affinity_kind::IO_PAIR:
-            // Legacy I/O pair spring used grad += W * dx (no 1/n). Pack-math kernel
-            // uses W_kernel / n; for n=2 set W_kernel = 2W to preserve strength.
-            return 2. * io_pair_attraction_weight_;
-        case e_affinity_kind::PACK_PATTERN:
-            return pack_pattern_weight_;
-        default:
-            VTR_ASSERT_MSG(false, "Unhandled affinity kind");
-            return 0.;
-    }
-}
-
 double AffinitySpringTerm::evaluate(const PartialPlacement& p_placement,
                                     std::optional<std::reference_wrapper<PlacementGradient>> grad) const {
     if (groups_.empty())
@@ -43,7 +27,7 @@ double AffinitySpringTerm::evaluate(const PartialPlacement& p_placement,
     double weighted_penalty = 0.;
     for (const AffinityGroup& group : groups_) {
         VTR_ASSERT_SAFE(group.blocks.size() >= 2);
-        double weight = kernel_weight_(group.kind);
+        double weight = pack_pattern_weight_;
         if (weight == 0.)
             continue;
 
@@ -75,7 +59,7 @@ double AffinitySpringTerm::evaluate(const PartialPlacement& p_placement,
 
 void AffinitySpringTerm::add_curvature(vtr::vector<APBlockId, double>& diagonal) const {
     for (const AffinityGroup& group : groups_) {
-        double curvature = affinity_spring_curvature(kernel_weight_(group.kind),
+        double curvature = affinity_spring_curvature(pack_pattern_weight_,
                                                      group.blocks.size());
         if (curvature == 0.)
             continue;

vpr/src/analytical_place/global_placement/affinity_spring_term.h

@@ -5,44 +5,31 @@
  * @date    August 2026
  * @brief   Quadratic centroid affinity-spring objective term.
  *
- * Groups of AP blocks (direct output-driver↔outpad pairs, long prepacker
- * chains) are pulled toward their group centroid by a quadratic spring. Group
- * *detection* stays with its producers (the placer's io-pair/pack-pattern
- * initialization); this term owns the groups' energy, gradient, and
- * preconditioner contribution.
+ * Groups of AP blocks (long prepacker chains) are pulled toward their group
+ * centroid by a quadratic spring. Group *detection* stays with its producer
+ * (the placer's pack-pattern initialization); this term owns the groups'
+ * energy, gradient, and preconditioner contribution.
  */
 
 #include <vector>
 #include "objective_term.h"
 
-/**
- * @brief Affinity-spring detector kind (logging / per-kind weights).
- */
-enum class e_affinity_kind {
-    IO_PAIR,     ///< Direct 2-pin output-driver↔outpad pairs.
-    PACK_PATTERN ///< Long prepacker chain groups spanning multiple AP blocks.
-};
-
 /**
  * @brief A set of AP blocks pulled together by a quadratic centroid spring.
  */
 struct AffinityGroup {
-    e_affinity_kind kind = e_affinity_kind::IO_PAIR; ///< Detector that created this group.
-    std::vector<APBlockId> blocks;                   ///< AP blocks in the group (size >= 2).
+    std::vector<APBlockId> blocks; ///< AP blocks in the group (size >= 2).
 };
 
 class AffinitySpringTerm final : public ObjectiveTerm {
   public:
     /**
      * @brief Construct with per-kind kernel inputs; precomputes block mobility.
      *
-     * @param io_pair_attraction_weight Legacy per-block I/O pair spring strength
-     *                                  (the kernel applies 2x for n=2 pack math).
      * @param pack_pattern_weight       Pack-pattern kernel weight; may later be
      *                                  zeroed via @ref set_pack_pattern_weight.
      */
     AffinitySpringTerm(const APNetlist& ap_netlist,
-                       double io_pair_attraction_weight,
                        double pack_pattern_weight);
 
     void clear_groups() { groups_.clear(); }
@@ -71,10 +58,8 @@ class AffinitySpringTerm final : public ObjectiveTerm {
     void add_curvature(vtr::vector<APBlockId, double>& diagonal) const final;
 
   private:
-    double kernel_weight_(e_affinity_kind kind) const;
 
     std::vector<AffinityGroup> groups_;
-    double io_pair_attraction_weight_ = 0.;
     double pack_pattern_weight_ = 0.;
     vtr::vector<APBlockId, bool> moveable_; ///< Block mobility, precomputed (static per netlist).
 };

vpr/src/analytical_place/global_placement/electrostatic_density_utils.cpp

@@ -63,7 +63,11 @@ void dct_ii(const std::vector<double>& input,
 }
 
 /**
- * @brief Apply the inverse of the unnormalized DCT-II through an inverse FFT.
+ * @brief Apply an inverse DCT-II via an inverse FFT.
+ *
+ * NOTE: this returns exactly 2x the true DCT-II inverse. The factor is a single
+ * frequency-independent scalar, absorbed by the density-weight normalization, so the
+ * field shape and all force directions are unaffected.
  */
 void idct_iii(const std::vector<double>& input,
               std::vector<double>& output,

vpr/src/analytical_place/global_placement/global_placer.cpp

@@ -380,6 +380,8 @@ void update_timing_info_with_partial_placement(PreClusterTimingManager& pre_clus
     // For each AP pin, update the delay of the timing arc going through it.
     // The timing manager operates on the Atom netlist; however, by construction
     // of the AP netlist, every atom pin corresponds 1to1 to an AP pin.
+    // Loop-invariant (depends only on the device center + delay model): hoisted out of the loop.
+    const float delay_per_tile = get_delay_per_tile(place_delay_model);
     for (APPinId ap_pin_id : ap_netlist.pins()) {
         // Timing arcs are uniquely identified by the sink pin. Only update
         // timing for sink pins.
@@ -421,7 +423,7 @@ void update_timing_info_with_partial_placement(PreClusterTimingManager& pre_clus
         if (delay >= ROUTER_LOOKAHEAD_NO_PATH_SENTINEL) {
             int manhattan_dist = std::abs(driver_block_loc.x - sink_block_loc.x)
                                  + std::abs(driver_block_loc.y - sink_block_loc.y);
-            delay = manhattan_dist * get_delay_per_tile(place_delay_model);
+            delay = manhattan_dist * delay_per_tile;
         }
 
         // Get the atom pin associated with this AP pin (i.e. the one the AP
@@ -588,6 +590,6 @@ PartialPlacement SimPLGlobalPlacer::place() {
                           *density_manager_,
                           pre_cluster_timing_manager_);
 
-    // Return the placement from the final iteration.
+    // Return the best placement found (lowest upper-bound HPWL), tracked across iterations.
     return best_p_placement;
 }

vpr/src/analytical_place/global_placement/global_placer.h

@@ -22,7 +22,6 @@
 class APNetlist;
 class AnalyticalSolver;
 class LogicalModels;
-class PartialLegalizer;
 class PlaceDelayModel;
 class PreClusterTimingManager;
 class Prepacker;

vpr/src/analytical_place/global_placement/net_cohesion.cpp

@@ -36,17 +36,14 @@ NetCohesion::NetCohesion(const APNetlist& ap_netlist,
                          size_t device_grid_width,
                          size_t device_grid_height,
                          size_t device_grid_num_layers,
-                         double periphery_pair_weight,
                          int log_verbosity)
     : ap_netlist_(ap_netlist)
     , density_manager_(density_manager)
     , device_grid_width_(device_grid_width)
     , device_grid_height_(device_grid_height)
     , device_grid_num_layers_(device_grid_num_layers)
-    , periphery_pair_weight_(periphery_pair_weight)
     , log_verbosity_(log_verbosity)
-    , periphery_pair_nets_(ap_netlist.nets().size(), false)
-    , periphery_pair_damping_(ap_netlist.nets().size(), 1.) {}
+    , periphery_pair_nets_(ap_netlist.nets().size(), false) {}
 
 void NetCohesion::identify_boundary_confined_dims(const std::vector<PrimitiveVectorDim>& dimensions) {
     std::vector<bool> boundary_confined(dimensions.size(), false);
@@ -140,9 +137,7 @@ bool NetCohesion::block_has_boundary_mass(APBlockId blk_id,
 
 void NetCohesion::update_periphery_pair_nets(const std::vector<PrimitiveVectorDim>& dimensions) {
     periphery_pair_nets_.resize(ap_netlist_.nets().size(), false);
-    periphery_pair_damping_.resize(ap_netlist_.nets().size(), 1.);
     std::fill(periphery_pair_nets_.begin(), periphery_pair_nets_.end(), false);
-    std::fill(periphery_pair_damping_.begin(), periphery_pair_damping_.end(), 1.);
     num_periphery_pair_nets_ = 0;
 
     // Boundary mass is a property of the block, not of the net, so evaluate it
@@ -155,17 +150,6 @@ void NetCohesion::update_periphery_pair_nets(const std::vector<PrimitiveVectorDi
             boundary_blocks++;
     }
 
-    // Block degree, counting only pins attached to a net.
-    vtr::vector<APBlockId, size_t> block_degree(ap_netlist_.blocks().size(), 0);
-    for (APBlockId blk_id : ap_netlist_.blocks()) {
-        for (APPinId pin_id : ap_netlist_.block_pins(blk_id)) {
-            if (ap_netlist_.pin_net(pin_id).is_valid())
-                block_degree[blk_id]++;
-        }
-    }
-
-    std::vector<size_t> selected_degrees;
-    std::vector<APNetId> selected_ids;
     for (APNetId net_id : ap_netlist_.nets()) {
         if (ap_netlist_.net_is_ignored(net_id))
             continue;
@@ -182,30 +166,12 @@ void NetCohesion::update_periphery_pair_nets(const std::vector<PrimitiveVectorDi
         // partial legalization scatters scarce periphery resources, so a
         // seed-length gate misses exactly the nets that need cohesion.
         periphery_pair_nets_[net_id] = true;
-        size_t degree = std::max(block_degree[first_blk_id], block_degree[second_blk_id]);
-        // Parked as the raw degree; normalized against the median below.
-        periphery_pair_damping_[net_id] = static_cast<double>(degree);
-        selected_degrees.push_back(degree);
-        selected_ids.push_back(net_id);
-    }
-    num_periphery_pair_nets_ = selected_ids.size();
-
-    // The reference degree is the median over the selected nets, so the damping
-    // is derived per design rather than tuned to any one architecture. Each
-    // net's degree is already parked in periphery_pair_damping_, so the median
-    // reorders selected_degrees in place instead of copying it.
-    if (!selected_degrees.empty()) {
-        auto median = selected_degrees.begin() + selected_degrees.size() / 2;
-        std::nth_element(selected_degrees.begin(), median, selected_degrees.end());
-        double ref = std::max<double>(1., static_cast<double>(*median));
-        for (APNetId net_id : selected_ids)
-            periphery_pair_damping_[net_id] = std::min(1., ref / std::max(1., periphery_pair_damping_[net_id]));
+        num_periphery_pair_nets_++;
     }
 
     if (log_verbosity_ >= 1) {
-        VTR_LOG("Nonlinear Nesterov periphery-pair cohesion: %zu boundary-mass blocks, %zu two-pin periphery nets, weight=%g.\n",
+        VTR_LOG("Nonlinear Nesterov periphery-pair cohesion: %zu boundary-mass blocks, %zu two-pin periphery nets.\n",
                 boundary_blocks,
-                num_periphery_pair_nets_,
-                periphery_pair_weight_);
+                num_periphery_pair_nets_);
     }
 }

vpr/src/analytical_place/global_placement/net_cohesion.h

@@ -6,11 +6,8 @@
  * @brief   Structural net-cohesion detection for the nonlinear Nesterov placer.
  *
  * The smooth wirelength objective lets two-pin nets between periphery-confined
- * blocks spread apart. Legalization then scatters those pairs, which downstream
- * packing and annealing cannot reliably repair. This module owns the detection
- * of that net class and the extra wirelength-weight multiplier that keeps its
- * endpoints together through the AP-to-APPack handoff; the placer applies the
- * multiplier inside its net-weight refresh.
+ * blocks spread apart. This module owns the detection of that net class; the
+ * placer uses the detected count to gate its pack-pattern affinity springs.
  *
  * The class is derived entirely from the parsed architecture: a resource
  * dimension is "boundary-confined" when the grid gives it capacity only near
@@ -31,8 +28,8 @@ class FlatPlacementDensityManager;
  *
  * Lifecycle per placement run: construct, call
  * @ref identify_boundary_confined_dims once the density dimensions are known,
- * then @ref update_periphery_pair_nets. Afterwards @ref net_multiplier yields
- * the cohesion weight factor for each net.
+ * then @ref update_periphery_pair_nets. @ref num_periphery_pair_nets then
+ * reports how many nets were flagged.
  */
 class NetCohesion {
   public:
@@ -41,7 +38,6 @@ class NetCohesion {
                 size_t device_grid_width,
                 size_t device_grid_height,
                 size_t device_grid_num_layers,
-                double periphery_pair_weight,
                 int log_verbosity);
 
     /**
@@ -61,41 +57,22 @@ class NetCohesion {
 
     /**
      * @brief Flag the two-pin nets whose endpoints both sit on boundary-confined
-     *        resources, and compute their degree damping.
+     *        resources.
      */
     void update_periphery_pair_nets(const std::vector<PrimitiveVectorDim>& dimensions);
 
     /// @brief Number of flagged periphery-pair nets (also gates pack-pattern affinity).
     size_t num_periphery_pair_nets() const { return num_periphery_pair_nets_; }
 
-    /**
-     * @brief Cohesion weight multiplier for one net (1.0 when unflagged).
-     */
-    double net_multiplier(APNetId net_id) const {
-        if (static_cast<size_t>(net_id) >= periphery_pair_nets_.size() || !periphery_pair_nets_[net_id])
-            return 1.;
-        // Degree-normalized cohesion. A block on many two-pin periphery nets
-        // accumulates the multiplier once per net, so its total pull scales with
-        // its degree; a high-fanout periphery structure therefore drags far
-        // harder than the simple pad-to-pad pair this class is meant to hold
-        // together. Scaling by a reference degree bounds each block's total
-        // contribution, which damps high-degree blocks without having to
-        // identify them.
-        return 1. + (periphery_pair_weight_ - 1.) * periphery_pair_damping_[net_id];
-    }
-
   private:
     const APNetlist& ap_netlist_;
     const FlatPlacementDensityManager& density_manager_;
     size_t device_grid_width_ = 0;
     size_t device_grid_height_ = 0;
     size_t device_grid_num_layers_ = 0;
-    double periphery_pair_weight_ = 1.0;
     int log_verbosity_ = 0;
 
     std::vector<bool> boundary_confined_dims_;
     vtr::vector<APNetId, bool> periphery_pair_nets_;
-    /// @brief Per-net degree damping in [0,1]; 1 keeps the full weight.
-    vtr::vector<APNetId, double> periphery_pair_damping_;
     size_t num_periphery_pair_nets_ = 0;
 };