Add new type of callback to reduce frequency of routing-driven calls

pycoloquinte/module.cpp

@@ -82,6 +82,7 @@ PYBIND11_MODULE(coloquinte_pybind, m) {
       .value("LowerBound", PlacementStep::LowerBound)
       .value("UpperBound", PlacementStep::UpperBound)
       .value("Detailed", PlacementStep::Detailed)
+      .value("PenaltyUpdate", PlacementStep::PenaltyUpdate)
       .export_values();
 
   py::class_<ColoquinteParameters>(m, "ColoquinteParameters")

src/coloquinte.hpp

@@ -66,7 +66,7 @@ struct Rectangle {
 /**
  * @brief Step of the placement process, for use in callbacks
  */
-enum class PlacementStep { LowerBound, UpperBound, Detailed };
+enum class PlacementStep { LowerBound, UpperBound, Detailed, PenaltyUpdate };
 
 /**
  * @brief Cost model to use when doing legalization
@@ -435,6 +435,19 @@ struct GlobalPlacerParameters {
    */
   double distanceTolerance;
 
+  /**
+   * @brief Distance between lower and upper bound placement at which we start
+   * doing rounting and timing driven placement by calling PenaltyUpdate
+   * callbacks
+   */
+  double penaltyUpdateDistance;
+
+  /**
+   * @brief Ratio to decrease the distance between lower and upper bound placement
+   * before we retry calling PenaltyUpdate callbacks
+   */
+  double penaltyUpdateBackoff;
+
   /**
    * @brief Blending between lower-bound and upper-bound placement at export
    * time; 0 to use lower bound, 1 to use upper bound

src/parameters.cpp

@@ -237,6 +237,8 @@ GlobalPlacerParameters::GlobalPlacerParameters(int effort)
   nbInitialSteps = 0;
   nbStepsBeforeRoughLegalization = 1;
   distanceTolerance = 2.0;
+  penaltyUpdateDistance = 10.0;
+  penaltyUpdateBackoff = 2.0;
   // TODO: find best parameter
   exportBlending = 0.99;
   noise = 1.0e-4;
@@ -423,6 +425,14 @@ void GlobalPlacerParameters::check() const {
     throw std::runtime_error(
         "Noise should be a very small non-negative number");
   }
+  if (penaltyUpdateDistance <= 0.0f) {
+    throw std::runtime_error(
+        "Invalid penalty update distance (should be positive)");
+  }
+  if (penaltyUpdateBackoff < 1.0f) {
+    throw std::runtime_error(
+        "Invalid penalty update backoff (should be at least 1)");
+  }
 }
 
 void LegalizationParameters::check() const {

src/place_global/place_global.cpp

@@ -151,6 +151,7 @@ void GlobalPlacer::run() {
   penalty_ = params_.global.penalty.initialValue;
   approximationDistance_ = initialApproximationDistance();
   penaltyCutoffDistance_ = initialPenaltyCutoffDistance();
+  double nextPenaltyUpdateDistance = penaltyUpdateDistance();
 
   float lb = valueLB();
   float ub = std::numeric_limits<float>::infinity();
@@ -171,6 +172,10 @@ void GlobalPlacer::run() {
       std::cout << std::endl;
       break;
     }
+    if (dist < nextPenaltyUpdateDistance) {
+      callback(PlacementStep::PenaltyUpdate, xPlacementUB_, yPlacementUB_);
+      nextPenaltyUpdateDistance /= params_.global.penaltyUpdateBackoff;
+    }
     for (int i = 0; i < params_.global.nbStepsBeforeRoughLegalization; ++i) {
       if (i != 0) {
         std::cout << "#" << step_ << ":\t........\t........";

src/place_global/place_global.hpp

@@ -108,6 +108,14 @@ class GlobalPlacer {
     return params_.global.distanceTolerance * averageCellLength_;
   }
 
+  /**
+   * @brief Distance between upper and lower bound at which we start routing
+   * and timing driven placement
+   */
+  float penaltyUpdateDistance() const {
+    return params_.global.penaltyUpdateDistance * averageCellLength_;
+  }
+
   /**
    * @brief Compute the penalty forces for this iteration
    */
@@ -148,4 +156,4 @@ class GlobalPlacer {
   std::optional<PlacementCallback> callback_;
 };
 
-}  // namespace coloquinte
+}  // namespace coloquinte