Merge pull request The-OpenROAD-Project#7395 from gudeh/gpl-update-routability-vector

gpl: update routability vector after instance removal

Author: maliberty

src/gpl/src/nesterovBase.cpp

@@ -282,11 +282,9 @@ void GCell::print(utl::Logger* logger, bool print_only_name = true) const
   }
 }
 
-void GCell::printToFile(const std::string& filename,
-                        bool print_only_name = true) const
+void GCell::printToFile(std::ostream& out, bool print_only_name) const
 {
-  std::ofstream out(filename, std::ios::app);
-  if (!out.is_open()) {
+  if (!out) {
     return;
   }
 
@@ -307,8 +305,6 @@ void GCell::printToFile(const std::string& filename,
                        gradientX_,
                        gradientY_);
   }
-
-  out.close();
 }
 
 ////////////////////////////////////////////////
@@ -1461,6 +1457,43 @@ int64_t NesterovBaseCommon::getHpwl()
   return hpwl;
 }
 
+void NesterovBaseCommon::resetMinRcCellSize()
+{
+  minRcCellSize_.clear();
+  minRcCellSize_.shrink_to_fit();
+}
+
+void NesterovBaseCommon::resizeMinRcCellSize()
+{
+  minRcCellSize_.resize(nbc_gcells_.size(), std::make_pair(0, 0));
+}
+
+void NesterovBaseCommon::updateMinRcCellSize()
+{
+  for (auto& gCell : nbc_gcells_) {
+    if (!gCell->isStdInstance()) {
+      continue;
+    }
+
+    minRcCellSize_[&gCell - nbc_gcells_.data()]
+        = std::make_pair(gCell->dx(), gCell->dy());
+  }
+}
+
+void NesterovBaseCommon::revertGCellSizeToMinRc()
+{
+  // revert back the gcell sizes
+  for (auto& gCell : nbc_gcells_) {
+    if (!gCell->isStdInstance()) {
+      continue;
+    }
+
+    int idx = &gCell - nbc_gcells_.data();
+
+    gCell->setSize(minRcCellSize_[idx].first, minRcCellSize_[idx].second);
+  }
+}
+
 GCell* NesterovBaseCommon::getGCellByIndex(size_t i)
 {
   if (i >= gCellStor_.size()) {
@@ -1932,9 +1965,9 @@ int NesterovBase::fillerDy() const
   return fillerDy_;
 }
 
-int NesterovBase::fillerCnt() const
+int NesterovBase::getFillerCnt() const
 {
-  return static_cast<int>(gCellFillers_.size());
+  return static_cast<int>(fillerStor_.size());
 }
 
 int64_t NesterovBase::fillerCellArea() const
@@ -2713,27 +2746,6 @@ void NesterovBase::nesterovAdjustPhi()
   }
 }
 
-void NesterovBase::cutFillerCoordinates()
-{
-  curSLPCoordi_.resize(fillerCnt());
-  curSLPWireLengthGrads_.resize(fillerCnt());
-  curSLPDensityGrads_.resize(fillerCnt());
-  curSLPSumGrads_.resize(fillerCnt());
-
-  nextSLPCoordi_.resize(fillerCnt());
-  nextSLPWireLengthGrads_.resize(fillerCnt());
-  nextSLPDensityGrads_.resize(fillerCnt());
-  nextSLPSumGrads_.resize(fillerCnt());
-
-  prevSLPCoordi_.resize(fillerCnt());
-  prevSLPWireLengthGrads_.resize(fillerCnt());
-  prevSLPDensityGrads_.resize(fillerCnt());
-  prevSLPSumGrads_.resize(fillerCnt());
-
-  curCoordi_.resize(fillerCnt());
-  nextCoordi_.resize(fillerCnt());
-}
-
 void NesterovBase::snapshot()
 {
   if (isConverged_) {
@@ -3000,9 +3012,7 @@ void NesterovBase::updateGCellState(float wlCoeffX, float wlCoeffY)
   new_instances.clear();
 }
 
-void NesterovBase::createCbkGCell(odb::dbInst* db_inst,
-                                  size_t stor_index,
-                                  RouteBase* rb)
+void NesterovBase::createCbkGCell(odb::dbInst* db_inst, size_t stor_index)
 {
   debugPrint(log_,
              GPL,
@@ -3039,7 +3049,6 @@ void NesterovBase::createCbkGCell(odb::dbInst* db_inst,
       snapshotSLPSumGrads_.emplace_back();
     }
 
-    rb->pushBackMinRcCellSize(gcell->dx(), gcell->dy());
   } else {
     debugPrint(log_,
                GPL,
@@ -3051,7 +3060,7 @@ void NesterovBase::createCbkGCell(odb::dbInst* db_inst,
 
 size_t NesterovBaseCommon::createCbkGCell(odb::dbInst* db_inst)
 {
-  debugPrint(log_, GPL, "callbacks", 2, "NBC createGCell");
+  debugPrint(log_, GPL, "callbacks", 2, "NBC createCbkGCell");
   Instance gpl_inst(db_inst,
                     pbc_->padLeft() * pbc_->siteSizeX(),
                     pbc_->padRight() * pbc_->siteSizeX(),
@@ -3061,6 +3070,7 @@ size_t NesterovBaseCommon::createCbkGCell(odb::dbInst* db_inst)
   pb_insts_stor_.push_back(gpl_inst);
   GCell gcell(&pb_insts_stor_.back());
   gCellStor_.push_back(gcell);
+  minRcCellSize_.emplace_back(gcell.dx(), gcell.dy());
   GCell* gcell_ptr = &gCellStor_.back();
   gCellMap_[gcell_ptr->insts()[0]] = gcell_ptr;
   db_inst_to_nbc_index_map_[db_inst] = gCellStor_.size() - 1;
@@ -3175,18 +3185,17 @@ std::pair<odb::dbInst*, size_t> NesterovBaseCommon::destroyCbkGCell(
   }
 
   size_t index_remove = it->second;
-  size_t last_index = gCellStor_.size() - 1;
-
   db_inst_to_nbc_index_map_.erase(it);
 
   std::pair<odb::dbInst*, size_t> replacement;
+  size_t last_index = gCellStor_.size() - 1;
 
   if (index_remove != last_index) {
     std::swap(gCellStor_[index_remove], gCellStor_[last_index]);
+    std::swap(minRcCellSize_[index_remove], minRcCellSize_[last_index]);
 
     odb::dbInst* swapped_inst = gCellStor_[index_remove].insts()[0]->dbInst();
     db_inst_to_nbc_index_map_[swapped_inst] = index_remove;
-
     replacement = {swapped_inst, index_remove};
   }
 
@@ -3195,6 +3204,7 @@ std::pair<odb::dbInst*, size_t> NesterovBaseCommon::destroyCbkGCell(
   delta_area_ -= area_change;
 
   gCellStor_.pop_back();
+  minRcCellSize_.pop_back();
   return replacement;
 }
 
@@ -3353,21 +3363,44 @@ void NesterovBaseCommon::printGCells()
   }
 }
 
-void NesterovBaseCommon::printGCellsToFile(const std::string& filename)
+void NesterovBaseCommon::printGCellsToFile(const std::string& filename,
+                                           bool print_only_name,
+                                           bool also_print_minRc)
 {
   std::ofstream out(filename);
   if (!out.is_open()) {
     return;
   }
 
   out << "gCellStor_.size(): " << gCellStor_.size() << "\n";
-  out.close();  // reuse printToFile which appends
+  out.close();
+
+  std::ofstream out_append(filename, std::ios::app);
+  if (!out_append.is_open()) {
+    return;
+  }
 
   for (size_t i = 0; i < gCellStor_.size(); ++i) {
-    std::ofstream out_idx(filename, std::ios::app);
-    out_idx << fmt::format("idx:{}\n", i);
-    out_idx.close();
-    gCellStor_[i].printToFile(filename);
+    out_append << fmt::format("idx:{}\n", i);
+    gCellStor_[i].printToFile(out_append, print_only_name);
+  }
+
+  out_append.close();
+
+  if (also_print_minRc) {
+    std::string minrc_filename = filename + ".minrc";
+    std::ofstream minrc_out(minrc_filename);
+    if (!minrc_out.is_open()) {
+      return;
+    }
+
+    for (size_t i = 0; i < minRcCellSize_.size(); ++i) {
+      const auto& min_rc = minRcCellSize_[i];
+      minrc_out << fmt::format(
+          "idx:{} minRc: {} {}\n", i, min_rc.first, min_rc.second);
+    }
+
+    minrc_out.close();
   }
 }
 

src/gpl/src/nesterovBase.h

@@ -111,7 +111,7 @@ class GCell
   bool contains(odb::dbInst* db_inst) const;
 
   void print(utl::Logger* logger, bool print_only_name) const;
-  void printToFile(const std::string& filename, bool print_only_name) const;
+  void printToFile(std::ostream& out, bool print_only_name = true) const;
 
  private:
   std::vector<Instance*> insts_;
@@ -838,6 +838,11 @@ class NesterovBaseCommon
   void moveGCell(odb::dbInst* db_inst);
   void fixPointers();
 
+  void resetMinRcCellSize();
+  void resizeMinRcCellSize();
+  void updateMinRcCellSize();
+  void revertGCellSizeToMinRc();
+
   GCell& getGCell(size_t index) { return gCellStor_[index]; }
 
   size_t getGCellIndex(const GCell* gCell) const
@@ -846,7 +851,9 @@ class NesterovBaseCommon
   }
 
   void printGCells();
-  void printGCellsToFile(const std::string& filename);
+  void printGCellsToFile(const std::string& filename,
+                         bool print_only_name = true,
+                         bool also_print_minRc = false);
   void printGPins();
 
   // TODO do this for each region? Also, manage this properly if other callbacks
@@ -866,6 +873,8 @@ class NesterovBaseCommon
   std::vector<GPin> gPinStor_;
 
   std::vector<GCell*> nbc_gcells_;
+  // For usage in routability mode, parallel to nbc_gcells_
+  std::vector<std::pair<int, int>> minRcCellSize_;
   std::vector<GNet*> gNets_;
   std::vector<GPin*> gPins_;
 
@@ -905,8 +914,6 @@ class NesterovBase
   GCell& getFillerGCell(size_t index) { return fillerStor_[index]; }
 
   const std::vector<GCellHandle>& getGCells() const { return nb_gcells_; }
-  const std::vector<GCell*>& gCellInsts() const { return gCellInsts_; }
-  const std::vector<GCell*>& gCellFillers() const { return gCellFillers_; }
 
   float getSumOverflow() const { return sumOverflow_; }
   float getSumOverflowUnscaled() const { return sumOverflowUnscaled_; }
@@ -935,7 +942,7 @@ class NesterovBase
   // will be used in Routability-driven loop
   int fillerDx() const;
   int fillerDy() const;
-  int fillerCnt() const;
+  int getFillerCnt() const;
   int64_t fillerCellArea() const;
   int64_t whiteSpaceArea() const;
   int64_t movableArea() const;
@@ -1040,7 +1047,6 @@ class NesterovBase
   void updateNextIter(int iter);
   void setTrueReprintIterHeader() { reprint_iter_header = true; }
   float getPhiCoef(float scaledDiffHpwl) const;
-  void cutFillerCoordinates();
 
   void snapshot();
 
@@ -1063,7 +1069,7 @@ class NesterovBase
 
   bool isDiverged() const { return isDiverged_; }
 
-  void createCbkGCell(odb::dbInst* db_inst, size_t stor_index, RouteBase* rb);
+  void createCbkGCell(odb::dbInst* db_inst, size_t stor_index);
   void destroyCbkGCell(odb::dbInst* db_inst);
   void destroyFillerGCell(size_t index_remove);
 
@@ -1092,10 +1098,7 @@ class NesterovBase
   int64_t macroInstsArea_ = 0;
 
   std::vector<GCell> fillerStor_;
-
   std::vector<GCellHandle> nb_gcells_;
-  std::vector<GCell*> gCellInsts_;
-  std::vector<GCell*> gCellFillers_;
 
   std::unordered_map<odb::dbInst*, size_t> db_inst_to_nb_index_map_;
 
@@ -1134,8 +1137,18 @@ class NesterovBase
   // save initial coordinates -- needed for RD
   std::vector<FloatPoint> initCoordi_;
 
-  // densityPenalty stor
-  std::vector<float> densityPenaltyStor_;
+  // Snapshot data for routability, parallel vectors
+  std::vector<FloatPoint> snapshotCoordi_;
+  std::vector<FloatPoint> snapshotSLPCoordi_;
+  std::vector<FloatPoint> snapshotSLPSumGrads_;
+  float snapshotDensityPenalty_ = 0;
+  float snapshotStepLength_ = 0;
+
+  // For destroying elements in parallel vectors
+  void swapAndPop(std::vector<FloatPoint>& vec,
+                  size_t remove_index,
+                  size_t last_index);
+  void swapAndPopParallelVectors(size_t remove_index, size_t last_index);
 
   float wireLengthGradSum_ = 0;
   float densityGradSum_ = 0;
@@ -1169,19 +1182,7 @@ class NesterovBase
   bool isConverged_ = false;
   bool reprint_iter_header;
 
-  // Snapshot data for routability, parallel vectors
-  std::vector<FloatPoint> snapshotCoordi_;
-  std::vector<FloatPoint> snapshotSLPCoordi_;
-  std::vector<FloatPoint> snapshotSLPSumGrads_;
-  float snapshotDensityPenalty_ = 0;
-  float snapshotStepLength_ = 0;
-
   void initFillerGCells();
-
-  void swapAndPop(std::vector<FloatPoint>& vec,
-                  size_t remove_index,
-                  size_t last_index);
-  void swapAndPopParallelVectors(size_t remove_index, size_t last_index);
 };
 
 inline std::vector<Bin>& NesterovBase::bins()

src/gpl/src/nesterovPlace.cpp

@@ -654,8 +654,6 @@ int NesterovPlace::doNesterovPlace(int start_iter)
 
       // if routability is needed
       if (is_routability_need_ || isRevertInitNeeded) {
-        // cutFillerCoordinates();
-
         // revert back the current density penality
         curA = route_snapshotA;
         wireLengthCoefX_ = route_snapshot_WlCoefX;
@@ -775,13 +773,13 @@ nesterovDbCbk::nesterovDbCbk(NesterovPlace* nesterov_place)
 {
 }
 
-void NesterovPlace::createGCell(odb::dbInst* db_inst)
+void NesterovPlace::createCbkGCell(odb::dbInst* db_inst)
 {
   auto gcell_index = nbc_->createCbkGCell(db_inst);
   for (auto& nesterov : nbVec_) {
     // TODO: manage regions, not every NB should create a
     // gcell.
-    nesterov->createCbkGCell(db_inst, gcell_index, rb_.get());
+    nesterov->createCbkGCell(db_inst, gcell_index);
   }
 }
 
@@ -844,7 +842,7 @@ void nesterovDbCbk::inDbPostMoveInst(odb::dbInst* db_inst)
 
 void nesterovDbCbk::inDbInstCreate(odb::dbInst* db_inst)
 {
-  nesterov_place_->createGCell(db_inst);
+  nesterov_place_->createCbkGCell(db_inst);
 }
 
 // TODO: use the region to create new gcell.