Merge branch 'master' of github.com:The-OpenROAD-Project-private/OpenROAD into grt-estimate-resistance

Author: jfgava

src/OpenRoad.cc

@@ -495,6 +495,7 @@ void OpenRoad::read3Dbx(const std::string& filename)
 {
   odb::ThreeDBlox parser(logger_, db_, sta_);
   parser.readDbx(filename);
+  parser.check();
 }
 
 void OpenRoad::read3DBloxBMap(const std::string& filename)

src/OpenRoad.tcl

@@ -430,7 +430,7 @@ proc place_inst { args } {
   }
 
   if { [info exists keys(-name)] } {
-    set inst_name [lindex $keys(-name) 0]
+    set inst_name $keys(-name)
   } else {
     utl::error ORD 57 "-name is a required argument to the place_cell command."
   }

src/cts/src/TechChar.cpp

@@ -942,18 +942,23 @@ std::vector<TechChar::SolutionData> TechChar::createPatterns(
   // can be placed and...
   //...the number of topologies (combinations of buffers, considering only 1
   // drive) that can exist.
+
   const unsigned numberOfNodes
       = setupWirelength / options_->getWireSegmentUnit();
   const unsigned numberOfTopologies = 1 << numberOfNodes;
   std::vector<SolutionData> topologiesVector;
   odb::dbNet* net = nullptr;
   // clang-format off
-  debugPrint(logger_, CTS, "tech char", 1, "createPatterns WL:{} #nodes:{}"
-             "#topo:{}", setupWirelength, numberOfNodes, numberOfTopologies);
+  debugPrint(logger_, CTS, "tech char", 1, "*createPatterns for #nodes = {}"
+             " #topologies = {}", setupWirelength, numberOfNodes, numberOfTopologies);
   // clang-format on
   // For each possible topology...
   for (unsigned solutionCounterInt = 0; solutionCounterInt < numberOfTopologies;
        solutionCounterInt++) {
+    debugPrint(
+        logger_, CTS, "tech char", 1, "**topology {}", solutionCounterInt + 1);
+    std::stringstream tmp;
+    tmp << "***IN ";
     // Creates a bitset that represents the buffer locations.
     const std::bitset<5> solutionCounter(solutionCounterInt);
     int wireCounter = 0;
@@ -983,20 +988,24 @@ std::vector<TechChar::SolutionData> TechChar::createPatterns(
         // Not a buffer, only a wire segment.
         nodesWithoutBuf++;
         // clang-format off
-        debugPrint(logger_, CTS, "tech char", 1, "  wire at node:{} topo:{}",
+        debugPrint(logger_, CTS, "tech char", 2, "***wire at node : {}",
                    nodeIndex, solutionCounterInt);
         // clang-format on
       } else {
         // Buffer, need to create the instance and a new net.
         nodesWithoutBuf++;
+        for (int i = 0; i < nodesWithoutBuf - 1; i++) {
+          tmp << "-- ";
+        }
+        tmp << "-> ";
         // Creates a new buffer instance.
         const std::string bufName = fmt::format("buf_{}_{}_{}",
                                                 setupWirelength,
                                                 solutionCounter.to_string(),
                                                 wireCounter);
         // clang-format off
-        debugPrint(logger_, CTS, "tech char", 1, "  buffer {} at node:{} "
-                   "topo:{}", bufName, nodeIndex, solutionCounterInt);
+        debugPrint(logger_, CTS, "tech char", 2, "***buffer {} at node : {}"
+                  , bufName, nodeIndex, solutionCounterInt);
         // clang-format on
         odb::dbInst* bufInstance
             = odb::dbInst::create(charBlock_, charBuf_, bufName.c_str());
@@ -1020,11 +1029,6 @@ std::vector<TechChar::SolutionData> TechChar::createPatterns(
         // Updates the topology wih the new instance and the current topology
         // (as a vector of strings).
         topology.instVector.push_back(bufInstance);
-        // clang-format off
-        debugPrint(logger_, CTS, "tech char", 1, "  topo instVector size:{} "
-                   "node:{} topo:{}", topology.instVector.size(), nodeIndex,
-                   solutionCounterInt);
-        // clang-format on
         topology.topologyDescriptor.push_back(
             std::to_string(nodesWithoutBuf * options_->getWireSegmentUnit()));
         topology.topologyDescriptor.push_back(charBuf_->getName());
@@ -1041,6 +1045,11 @@ std::vector<TechChar::SolutionData> TechChar::createPatterns(
     odb::dbBPin* outPortPin = odb::dbBPin::create(outPort);
     // Updates the topology with the output port, old new, possible instances
     // and other attributes.
+    for (int i = 0; i < nodesWithoutBuf; i++) {
+      tmp << "-- ";
+    }
+    tmp << "OUT";
+    debugPrint(logger_, CTS, "tech char", 1, tmp.str());
     topology.outPort = outPortPin;
     if (isPureWire) {
       topology.instVector.push_back(nullptr);
@@ -1194,7 +1203,7 @@ TechChar::ResultData TechChar::computeTopologyResults(
   const float pinArrival = openStaChar_->vertexArrival(
       outPinVert, sta::RiseFall::fall(), charPathAnalysis_);
   results.pinArrival = pinArrival;
-  // Computations for output slew.
+  // Computations for output slew. Avg of rise and fall slew.
   const float pinRise = openStaChar_->vertexSlew(
       outPinVert, sta::RiseFall::rise(), sta::MinMax::max());
   const float pinFall = openStaChar_->vertexSlew(
@@ -1333,7 +1342,7 @@ void TechChar::updateBufferTopologies(TechChar::SolutionData& solution)
       odb::dbInst* inst = solution.instVector[nodeIndex];
       inst->swapMaster(newMaster);
       // clang-format off
-      debugPrint(logger_, CTS, "tech char", 1, "**updateBufferTopologies swap "
+      debugPrint(logger_, CTS, "tech char", 1, "***updateBufferTopologies swap "
                  "from {} to {}, index:{}", oldMaster->getName(),
                  newMaster->getName(), nodeIndex);
       // clang-format on
@@ -1344,6 +1353,10 @@ void TechChar::updateBufferTopologies(TechChar::SolutionData& solution)
 
 std::vector<size_t> TechChar::getCurrConfig(const SolutionData& solution)
 {
+  if (solution.isPureWire) {
+    debugPrint(logger_, CTS, "tech char", 1, "**currConfig is a pure wire");
+    return {};
+  }
   std::vector<size_t> config;
   for (auto inst : solution.instVector) {
     size_t masterID = cellNameToID(inst->getMaster()->getName());
@@ -1352,11 +1365,11 @@ std::vector<size_t> TechChar::getCurrConfig(const SolutionData& solution)
 
   if (logger_->debugCheck(CTS, "tech char", 1)) {
     std::stringstream tmp;
-    tmp << "currConfig: ";
+    tmp << "**currConfig: ";
     for (unsigned i : config) {
       tmp << i << " ";
     }
-    logger_->report(tmp.str());
+    debugPrint(logger_, CTS, "tech char", 1, tmp.str());
   }
   return config;
 }
@@ -1368,7 +1381,7 @@ size_t TechChar::cellNameToID(const std::string& masterName)
   return std::distance(masterNames_.begin(), masterIter);
 }
 
-// Find a buffer config that is monotonic from current buffer config
+// Find a buffer config that is monotonic from current buffer config.
 std::vector<size_t> TechChar::getNextConfig(
     const std::vector<size_t>& currConfig)
 {
@@ -1392,11 +1405,11 @@ std::vector<size_t> TechChar::getNextConfig(
 
   if (logger_->debugCheck(CTS, "tech char", 1)) {
     std::stringstream tmp;
-    tmp << "nextConfig: ";
+    tmp << "**nextConfig: ";
     for (unsigned i : nextConfig) {
       tmp << i << " ";
     }
-    logger_->report(tmp.str());
+    debugPrint(logger_, CTS, "tech char", 1, tmp.str());
   }
 
   return nextConfig;
@@ -1426,15 +1439,15 @@ void TechChar::swapTopologyBuffer(SolutionData& solution,
        topologyIndex++) {
     const std::string topologyS = solution.topologyDescriptor[topologyIndex];
     // clang-format off
-    debugPrint(logger_, CTS, "tech char", 1, "**topo:{} topoIdx:{}",
+    debugPrint(logger_, CTS, "tech char", 1, "***topo:{} topoIdx:{}",
                topologyS, topologyIndex);
     // clang-format on
     if (!(std::find(masterNames_.begin(), masterNames_.end(), topologyS)
           == masterNames_.end())) {
       if (topologyCounter == nodeIndex) {
         solution.topologyDescriptor[topologyIndex] = newMasterName;
         // clang-format off
-        debugPrint(logger_, CTS, "tech char", 1, "**soln topo descript at "
+        debugPrint(logger_, CTS, "tech char", 1, "***soln topo descript at "
                    "{} set to {}", topologyIndex, newMasterName);
         // clang-format on
         break;
@@ -1561,6 +1574,8 @@ void TechChar::create()
   int64_t topologiesCreated = 0;
   for (unsigned setupWirelength : wirelengthsToTest_) {
     // Creates the topologies for the current wirelength.
+    debugPrint(
+        logger_, CTS, "tech char", 1, "Wirelength = {}", setupWirelength);
     std::vector<SolutionData> topologiesVector
         = createPatterns(setupWirelength);
     // Creates an OpenSTA instance.
@@ -1572,9 +1587,8 @@ void TechChar::create()
     int topoIndex = 0;
     for (SolutionData solution : topologiesVector) {
       // clang-format off
-      debugPrint(logger_, CTS, "tech char", 1, "create WL:{} of {}, "
-                 "topo:{} of {}", setupWirelength, wirelengthsToTest_.size(),
-                 topoIndex, topologiesVector.size());
+      debugPrint(logger_, CTS, "tech char", 1, "*genrate combinations for "
+                 "topology: {} of {}", topoIndex + 1, topologiesVector.size());
       // clang-format on
       topoIndex++;
       // Gets the input and output port (as terms, pins and vertices).
@@ -1610,15 +1624,15 @@ void TechChar::create()
                                  r1,
                                  c1,
                                  piExists);
+
+      // clang-format off
+      debugPrint(logger_, CTS, "tech char", 1, "*# bufs = {}; "
+                 "# nodes with buf = {}",
+                 masterNames_.size(), solution.instVector.size());
+      // clang-format on
       // For each possible buffer combination (different sizes).
       unsigned buffersUpdate
           = getBufferingCombo(masterNames_.size(), solution.instVector.size());
-      // clang-format off
-      debugPrint(logger_, CTS, "tech char", 1, "create #bufs={} "
-                 "#soln.instVector.size={}, #bufUpdate={}, #topo={}",
-                 masterNames_.size(), solution.instVector.size(),
-                 buffersUpdate, topologiesCreated);
-      // clang-format on
 
       if (buffersUpdate == 0) {
         continue;
@@ -1737,14 +1751,15 @@ void TechChar::create()
 unsigned TechChar::getBufferingCombo(size_t numBuffers, size_t numNodes)
 {
   // check if this has been computed already
-  std::stringstream tmp;
   std::pair iPair(numBuffers, numNodes);
   auto iter = bufferingComboTable_.find(iPair);
   if (iter != bufferingComboTable_.end()) {
-    if (logger_->debugCheck(CTS, "tech char", 1)) {
-      tmp << "Monotonic entries (hashed): " << iter->second << '\n';
-      logger_->report(tmp.str());
-    }
+    debugPrint(logger_,
+               CTS,
+               "tech char",
+               1,
+               "**Monotonic entries are already hashed: {}",
+               iter->second);
     return iter->second;
   }
 
@@ -1762,6 +1777,8 @@ unsigned TechChar::getBufferingCombo(size_t numBuffers, size_t numNodes)
 
   unsigned numMonotonic = 0;
   for (const auto& row : matrix) {
+    std::stringstream tmp;
+    tmp << "**";
     for (size_t val : row) {
       if (logger_->debugCheck(CTS, "tech char", 1)) {
         tmp << val << " ";
@@ -1773,15 +1790,10 @@ unsigned TechChar::getBufferingCombo(size_t numBuffers, size_t numNodes)
       }
       numMonotonic++;
     }
-    if (logger_->debugCheck(CTS, "tech char", 1)) {
-      logger_->report(tmp.str());
-    }
-  }
-  if (logger_->debugCheck(CTS, "tech char", 1)) {
-    tmp << "Monotonic entries: " << numMonotonic;
-    logger_->report(tmp.str());
+    debugPrint(logger_, CTS, "tech char", 1, tmp.str());
   }
-
+  debugPrint(
+      logger_, CTS, "tech char", 1, "**Monotonic entries: {}", numMonotonic);
   // insert new result into hash table
   bufferingComboTable_[iPair] = numMonotonic;
   return numMonotonic;

src/dbSta/include/db_sta/dbNetwork.hh

@@ -251,8 +251,26 @@ class dbNetwork : public ConcreteNetwork
   Instance* instance(const Pin* pin) const override;
   Net* net(const Pin* pin) const override;
   void net(const Pin* pin, dbNet*& db_net, dbModNet*& db_modnet) const;
+
+  ///
+  /// Get a dbNet connected to the input pin.
+  /// - If both dbNet and dbModNet are connected to the input pin,
+  ///   this function returns the dbNet.
+  /// - NOTE: If only dbModNet is connected to the input pin, this
+  ///   function returns nullptr. If you need to get the dbNet corresponding to
+  ///   the dbModNet, use findFlatDbNet() instead.
+  ///
   dbNet* flatNet(const Pin* pin) const;
+
+  ///
+  /// Get a dbModNet connected to the input pin.
+  /// - If both dbNet and dbModNet are connected to the input pin,
+  ///   this function returns the dbModNet.
+  /// - If only dbNet is connected to the input pin, this function returns
+  ///   nullptr.
+  ///
   dbModNet* hierNet(const Pin* pin) const;
+
   dbITerm* flatPin(const Pin* pin) const;
   dbModITerm* hierPin(const Pin* pin) const;
   dbBlock* getBlockOf(const Pin* pin) const;

src/grt/src/GlobalRouter.cpp

@@ -80,6 +80,7 @@ GlobalRouter::GlobalRouter(utl::Logger* logger,
       grid_origin_(0, 0),
       groute_renderer_(nullptr),
       grid_(new Grid),
+      is_incremental_(false),
       adjustment_(0.0),
       congestion_report_iter_step_(0),
       allow_congestion_(false),
@@ -2331,8 +2332,7 @@ void GlobalRouter::loadGuidesFromDB()
 void GlobalRouter::ensurePinsPositions(odb::dbNet* db_net)
 {
   std::string pins_not_covered;
-  netIsCovered(db_net, pins_not_covered);
-  if (!pins_not_covered.empty()) {
+  if (!netIsCovered(db_net, pins_not_covered)) {
     Net* net = db_net_map_[db_net];
     for (Pin& pin : net->getPins()) {
       if (pins_not_covered.find(pin.getName()) != std::string::npos) {
@@ -2487,6 +2487,12 @@ void GlobalRouter::computeGCellGridPatternFromGuides(
 
   grid_->setXGrids(x_grids);
   grid_->setYGrids(y_grids);
+
+  // update fastroute grid info with grid pattern calculated from guides
+  fastroute_->setTileSize(std::min(tile_size_x, tile_size_y));
+  fastroute_->setGridsAndLayers(
+      grid_->getXGrids(), grid_->getYGrids(), grid_->getNumLayers());
+  fastroute_->init3DEdges();
 }
 
 void GlobalRouter::fillTileSizeMaps(
@@ -5681,6 +5687,8 @@ std::vector<Net*> GlobalRouter::updateDirtyRoutes(bool save_guides)
     }
   }
 
+  fastroute_->setIncrementalGrt(false);
+
   return dirty_nets;
 }
 
@@ -5720,6 +5728,7 @@ void GlobalRouter::initFastRouteIncr(std::vector<Net*>& nets)
 {
   initNetlist(nets);
   fastroute_->initAuxVar();
+  fastroute_->setIncrementalGrt(true);
 }
 
 GRouteDbCbk::GRouteDbCbk(GlobalRouter* grouter) : grouter_(grouter)

src/grt/src/RepairAntennas.cpp

@@ -41,7 +41,10 @@ RepairAntennas::RepairAntennas(GlobalRouter* grouter,
       unique_diode_index_(1),
       illegal_diode_placement_count_(0),
       has_new_violations_(false),
-      routing_source_(RoutingSource::None)
+      routing_source_(RoutingSource::None),
+      tile_size_(0),
+      jumper_size_(0),
+      smaller_seg_size_(0)
 {
   block_ = db_->getChip()->getBlock();
   while (block_->findInst(

src/grt/src/Rudy.cpp

@@ -47,7 +47,11 @@ Rudy::Rudy(odb::dbBlock* block, grt::GlobalRouter* grouter)
     }
     pitch_terms += 1.0 / pitch;
   }
-  wire_width_ = (1 / pitch_terms) * 1.25;  // = harm. mean / num_routing_layers
+
+  if (pitch_terms != 0) {
+    wire_width_
+        = (1 / pitch_terms) * 1.25;  // = harm. mean / num_routing_layers
+  }
 
   int x_grids, y_grids;
   grouter_->getGridSize(x_grids, y_grids);

src/grt/src/cugr/src/GridGraph.cpp

@@ -405,6 +405,14 @@ AccessPointSet GridGraph::selectAccessPoints(const GRNet* net) const
     if (bestAccessDist.first == 0) {
       logger_->warn(utl::GRT, 274, "pin is hard to access.");
     }
+
+    if (bestIndex == -1) {
+      logger_->error(utl::GRT,
+                     283,
+                     "No preferred access point found for pin on net {}.",
+                     net->getName());
+    }
+
     const PointT selectedPoint = accessPoints[bestIndex];
     const AccessPoint ap{selectedPoint, {}};
     auto it = selected_access_points.emplace(ap).first;