gpl: improve main loop readability

Signed-off-by: Augusto Berndt <[email protected]>

Author: gudeh

src/gpl/src/nesterovPlace.cpp

@@ -365,165 +365,170 @@ void NesterovPlace::runTimingDriven(const int iter,
                                     const std::string& timing_driven_dir,
                                     const int routability_driven_revert_count,
                                     int& timing_driven_count,
-                                    int64_t& td_accumulated_delta_area)
+                                    int64_t& td_accumulated_delta_area,
+                                    bool is_routability_gpl_iter)
 {
   // timing driven feature
   // if virtual, do reweight on timing-critical nets,
   // otherwise keep all modifications by rsz.
+  if (npVars_.timingDrivenMode
+      && tb_->isTimingNetWeightOverflow(average_overflow_unscaled_)
+      && (!is_routability_gpl_iter || !npVars_.routability_driven_mode)) {
+    // update db's instance location from current density coordinates
+    updateDb();
 
-  // update db's instance location from current density coordinates
-  updateDb();
-
-  if (graphics_) {
-    graphics_->addTimingDrivenIter(iter);
+    if (graphics_) {
+      graphics_->addTimingDrivenIter(iter);
 
-    if (npVars_.debug_generate_images) {
-      graphics_->saveLabeledImage(
-          fmt::format("{}/timing_{:05d}_0.png", timing_driven_dir, iter),
-          fmt::format("Iter {} |R: {} |T: {} before TD",
-                      iter,
-                      routability_driven_revert_count,
-                      timing_driven_count),
-          /* select_buffers = */ false);
+      if (npVars_.debug_generate_images) {
+        graphics_->saveLabeledImage(
+            fmt::format("{}/timing_{:05d}_0.png", timing_driven_dir, iter),
+            fmt::format("Iter {} |R: {} |T: {} before TD",
+                        iter,
+                        routability_driven_revert_count,
+                        timing_driven_count),
+            /* select_buffers = */ false);
+      }
     }
-  }
 
-  // Call resizer's estimateRC API to fill in PEX using placed locations,
-  // Call sta's API to extract worst timing paths,
-  // and update GNet's weights from worst timing paths.
-  //
-  // See timingBase.cpp in detail
-  bool virtual_td_iter
-      = (average_overflow_unscaled_ > npVars_.keepResizeBelowOverflow);
+    // Call resizer's estimateRC API to fill in PEX using placed locations,
+    // Call sta's API to extract worst timing paths,
+    // and update GNet's weights from worst timing paths.
+    //
+    // See timingBase.cpp in detail
+    bool virtual_td_iter
+        = (average_overflow_unscaled_ > npVars_.keepResizeBelowOverflow);
 
-  log_->info(GPL,
-             100,
-             "Timing-driven iteration {}/{}, virtual: {}.",
-             ++npVars_.timingDrivenIterCounter,
-             tb_->getTimingNetWeightOverflowSize(),
-             virtual_td_iter);
+    log_->info(GPL,
+               100,
+               "Timing-driven iteration {}/{}, virtual: {}.",
+               ++npVars_.timingDrivenIterCounter,
+               tb_->getTimingNetWeightOverflowSize(),
+               virtual_td_iter);
 
-  log_->info(GPL,
-             101,
-             "   Iter: {}, overflow: {:.3f}, keep resizer changes at: {}, "
-             "HPWL: {}",
-             iter + 1,
-             average_overflow_unscaled_,
-             npVars_.keepResizeBelowOverflow,
-             nbc_->getHpwl());
-
-  if (!virtual_td_iter) {
-    db_cbk_->addOwner(pbc_->db()->getChip()->getBlock());
-  } else {
-    db_cbk_->removeOwner();
-  }
+    log_->info(GPL,
+               101,
+               "   Iter: {}, overflow: {:.3f}, keep resizer changes at: {}, "
+               "HPWL: {}",
+               iter + 1,
+               average_overflow_unscaled_,
+               npVars_.keepResizeBelowOverflow,
+               nbc_->getHpwl());
+
+    if (!virtual_td_iter) {
+      db_cbk_->addOwner(pbc_->db()->getChip()->getBlock());
+    } else {
+      db_cbk_->removeOwner();
+    }
 
-  auto block = pbc_->db()->getChip()->getBlock();
-  int nb_total_gcells_delta = 0;
-  int nb_gcells_before_td = 0;
-  int nb_gcells_after_td = 0;
-  int nbc_total_gcells_before_td = nbc_->getNewGcellsCount();
-  for (auto& nb : nbVec_) {
-    nb_gcells_before_td += nb->getGCells().size();
-  }
+    auto block = pbc_->db()->getChip()->getBlock();
+    int nb_total_gcells_delta = 0;
+    int nb_gcells_before_td = 0;
+    int nb_gcells_after_td = 0;
+    int nbc_total_gcells_before_td = nbc_->getNewGcellsCount();
+    for (auto& nb : nbVec_) {
+      nb_gcells_before_td += nb->getGCells().size();
+    }
 
-  bool shouldTdProceed = tb_->executeTimingDriven(virtual_td_iter);
-  nbVec_[0]->setTrueReprintIterHeader();
-  ++timing_driven_count;
+    bool shouldTdProceed = tb_->executeTimingDriven(virtual_td_iter);
+    nbVec_[0]->setTrueReprintIterHeader();
+    ++timing_driven_count;
 
-  td_accumulated_delta_area += nbc_->getDeltaArea();
-  for (auto& nb : nbVec_) {
-    nb_gcells_after_td += nb->getGCells().size();
-  }
-  nb_total_gcells_delta = nb_gcells_after_td - nb_gcells_before_td;
-  if (nb_total_gcells_delta != nbc_->getNewGcellsCount()) {
-    log_->warn(GPL,
-               92,
-               "Mismatch in #cells between central object and all regions. "
-               "NesterovBaseCommon: {}, Summing all regions: {}",
-               nbc_->getNewGcellsCount(),
-               nb_total_gcells_delta);
-  }
+    td_accumulated_delta_area += nbc_->getDeltaArea();
+    for (auto& nb : nbVec_) {
+      nb_gcells_after_td += nb->getGCells().size();
+    }
+    nb_total_gcells_delta = nb_gcells_after_td - nb_gcells_before_td;
+    if (nb_total_gcells_delta != nbc_->getNewGcellsCount()) {
+      log_->warn(GPL,
+                 92,
+                 "Mismatch in #cells between central object and all regions. "
+                 "NesterovBaseCommon: {}, Summing all regions: {}",
+                 nbc_->getNewGcellsCount(),
+                 nb_total_gcells_delta);
+    }
 
-  if (graphics_ && npVars_.debug_generate_images) {
-    updateDb();
-    bool select_buffers = !virtual_td_iter;
-    graphics_->saveLabeledImage(
-        fmt::format("{}/timing_{:05d}_1.png", timing_driven_dir, iter),
-        fmt::format("Iter {} |R: {} |T: {} after TD",
-                    iter,
-                    routability_driven_revert_count,
-                    timing_driven_count),
-        select_buffers);
-  }
+    if (graphics_ && npVars_.debug_generate_images) {
+      updateDb();
+      bool select_buffers = !virtual_td_iter;
+      graphics_->saveLabeledImage(
+          fmt::format("{}/timing_{:05d}_1.png", timing_driven_dir, iter),
+          fmt::format("Iter {} |R: {} |T: {} after TD",
+                      iter,
+                      routability_driven_revert_count,
+                      timing_driven_count),
+          select_buffers);
+    }
 
-  if (!virtual_td_iter) {
-    for (auto& nesterov : nbVec_) {
-      nesterov->updateGCellState(wireLengthCoefX_, wireLengthCoefY_);
-      // updates order in routability:
-      // 1. change areas
-      // 2. set target density with delta area
-      // 3. updateareas
-      // 4. updateDensitySize
-
-      nesterov->setTargetDensity(
-          static_cast<float>(nbc_->getDeltaArea()
-                             + nesterov->nesterovInstsArea()
-                             + nesterov->getTotalFillerArea())
-          / static_cast<float>(nesterov->whiteSpaceArea()));
-
-      float rsz_delta_area_microns
-          = block->dbuAreaToMicrons(nbc_->getDeltaArea());
-      float rsz_delta_area_percentage
-          = (nbc_->getDeltaArea()
-             / static_cast<float>(nesterov->nesterovInstsArea()))
-            * 100.0f;
-      log_->info(
-          GPL,
-          107,
-          "Timing-driven: repair_design delta area: {:.3f} um^2 ({:+.2f}%)",
-          rsz_delta_area_microns,
-          rsz_delta_area_percentage);
-
-      float new_gcells_percentage = 0.0f;
-      if (nbc_total_gcells_before_td > 0) {
-        new_gcells_percentage
-            = (nbc_->getNewGcellsCount()
-               / static_cast<float>(nbc_total_gcells_before_td))
+    if (!virtual_td_iter) {
+      for (auto& nesterov : nbVec_) {
+        nesterov->updateGCellState(wireLengthCoefX_, wireLengthCoefY_);
+        // updates order in routability:
+        // 1. change areas
+        // 2. set target density with delta area
+        // 3. updateareas
+        // 4. updateDensitySize
+
+        nesterov->setTargetDensity(
+            static_cast<float>(nbc_->getDeltaArea()
+                               + nesterov->nesterovInstsArea()
+                               + nesterov->getTotalFillerArea())
+            / static_cast<float>(nesterov->whiteSpaceArea()));
+
+        float rsz_delta_area_microns
+            = block->dbuAreaToMicrons(nbc_->getDeltaArea());
+        float rsz_delta_area_percentage
+            = (nbc_->getDeltaArea()
+               / static_cast<float>(nesterov->nesterovInstsArea()))
               * 100.0f;
+        log_->info(
+            GPL,
+            107,
+            "Timing-driven: repair_design delta area: {:.3f} um^2 ({:+.2f}%)",
+            rsz_delta_area_microns,
+            rsz_delta_area_percentage);
+
+        float new_gcells_percentage = 0.0f;
+        if (nbc_total_gcells_before_td > 0) {
+          new_gcells_percentage
+              = (nbc_->getNewGcellsCount()
+                 / static_cast<float>(nbc_total_gcells_before_td))
+                * 100.0f;
+        }
+        log_->info(
+            GPL,
+            108,
+            "Timing-driven: repair_design, gpl cells created: {} ({:+.2f}%)",
+            nbc_->getNewGcellsCount(),
+            new_gcells_percentage);
+
+        log_->info(GPL,
+                   110,
+                   "Timing-driven: new target density: {}",
+                   nesterov->targetDensity());
+        nbc_->resetDeltaArea();
+        nbc_->resetNewGcellsCount();
+        nesterov->updateAreas();
+        nesterov->updateDensitySize();
       }
-      log_->info(
-          GPL,
-          108,
-          "Timing-driven: repair_design, gpl cells created: {} ({:+.2f}%)",
-          nbc_->getNewGcellsCount(),
-          new_gcells_percentage);
 
-      log_->info(GPL,
-                 110,
-                 "Timing-driven: new target density: {}",
-                 nesterov->targetDensity());
-      nbc_->resetDeltaArea();
-      nbc_->resetNewGcellsCount();
-      nesterov->updateAreas();
-      nesterov->updateDensitySize();
+      // update snapshot after non-virtual TD
+      int64_t hpwl = nbc_->getHpwl();
+      if (average_overflow_unscaled_ <= 0.25) {
+        min_hpwl_ = hpwl;
+        diverge_snapshot_average_overflow_unscaled_
+            = average_overflow_unscaled_;
+        diverge_snapshot_iter_ = iter + 1;
+        is_min_hpwl_ = true;
+      }
     }
 
-    // update snapshot after non-virtual TD
-    int64_t hpwl = nbc_->getHpwl();
-    if (average_overflow_unscaled_ <= 0.25) {
-      min_hpwl_ = hpwl;
-      diverge_snapshot_average_overflow_unscaled_ = average_overflow_unscaled_;
-      diverge_snapshot_iter_ = iter + 1;
-      is_min_hpwl_ = true;
+    // problem occured
+    // escape timing driven later
+    if (!shouldTdProceed) {
+      npVars_.timingDrivenMode = false;
     }
   }
-
-  // problem occured
-  // escape timing driven later
-  if (!shouldTdProceed) {
-    npVars_.timingDrivenMode = false;
-  }
 }
 
 bool NesterovPlace::isDiverged(float& diverge_snapshot_WlCoefX,
@@ -1010,15 +1015,12 @@ int NesterovPlace::doNesterovPlace(const int start_iter)
       ++npVars_.maxNesterovIter;
     }
 
-    if (npVars_.timingDrivenMode
-        && tb_->isTimingNetWeightOverflow(average_overflow_unscaled_)
-        && (!is_routability_gpl_iter || !npVars_.routability_driven_mode)) {
-      runTimingDriven(nesterov_iter,
-                      timing_driven_dir,
-                      routability_driven_revert_count,
-                      timing_driven_count,
-                      td_accumulated_delta_area);
-    }
+    runTimingDriven(nesterov_iter,
+                    timing_driven_dir,
+                    routability_driven_revert_count,
+                    timing_driven_count,
+                    td_accumulated_delta_area,
+                    is_routability_gpl_iter);
 
     if (isDiverged(diverge_snapshot_WlCoefX,
                    diverge_snapshot_WlCoefY,

src/gpl/src/nesterovPlace.h

@@ -87,7 +87,8 @@ class NesterovPlace
                        const std::string& timing_driven_dir,
                        int routability_driven_count,
                        int& timing_driven_count,
-                       int64_t& td_accumulated_delta_area);
+                       int64_t& td_accumulated_delta_area,
+                       bool is_routability_gpl_iter);
   bool isDiverged(float& diverge_snapshot_WlCoefX,
                   float& diverge_snapshot_WlCoefY,
                   bool& is_diverge_snapshot_saved);