Merge pull request The-OpenROAD-Project#7174 from arthurjolo/cts_use_different_parameters_to_cluster_macros

Cts use different parameters to cluster macros

Author: precisionmoon

src/cts/README.md

@@ -53,6 +53,8 @@ clock_tree_synthesis
     [-clustering_unbalance_ratio]
     [-sink_clustering_size cluster_size]
     [-sink_clustering_max_diameter max_diameter]
+    [-macro_clustering_size cluster_size]
+    [-macro_clustering_max_diameter max_diameter]
     [-sink_clustering_enable]
     [-balance_levels]
     [-sink_clustering_levels levels]
@@ -78,8 +80,10 @@ clock_tree_synthesis
 | `-clustering_exponent` | Value that determines the power used on the difference between sink and means on the CKMeans clustering algorithm. The default value is `4`, and the allowed values are integers `[0, MAX_INT]`. |
 | `-clustering_unbalance_ratio` | Value determines each cluster's maximum capacity during CKMeans. A value of `0.5` (i.e., 50%) means that each cluster will have exactly half of all sinks for a specific region (half for each branch). The default value is `0.6`, and the allowed values are floats `[0, 1.0]`. |
 | `-sink_clustering_enable` | Enables pre-clustering of sinks to create one level of sub-tree before building H-tree. Each cluster is driven by buffer which becomes end point of H-tree structure. |
-| `-sink_clustering_size` | Specifies the maximum number of sinks per cluster. The default value is `20`, and the allowed values are integers `[0, MAX_INT]`. |
-| `-sink_clustering_max_diameter` | Specifies maximum diameter (in microns) of sink cluster. The default value is `50`, and the allowed values are integers `[0, MAX_INT]`. |
+| `-sink_clustering_size` | Specifies the maximum number of sinks per cluster for the register tree. The default value is `20`, and the allowed values are integers `[0, MAX_INT]`. |
+| `-sink_clustering_max_diameter` | Specifies maximum diameter (in microns) of sink cluster for the register tree. The default value is `50`, and the allowed values are integers `[0, MAX_INT]`. |
+| `-macro_clustering_size` | Specifies the maximum number of sinks per cluster for the macro tree. The default value is `4`, and the allowed values are integers `[0, MAX_INT]`. |
+| `-macro_clustering_max_diameter` | Specifies maximum diameter (in microns) of sink cluster for the macro tree. The default value is `50`, and the allowed values are integers `[0, MAX_INT]`. |
 | `-balance_levels` | Attempt to keep a similar number of levels in the clock tree across non-register cells (e.g., clock-gate or inverter). The default value is `False`, and the allowed values are bool. |
 | `-clk_nets` | String containing the names of the clock roots. If this parameter is omitted, `cts` looks for the clock roots automatically. |
 | `-num_static_layers` | Set the number of static layers. The default value is `0`, and the allowed values are integers `[0, MAX_INT]`. |

src/cts/src/CtsOptions.h

@@ -192,6 +192,24 @@ class CtsOptions : public odb::dbBlockCallBackObj
   {
     sinkClusteringLevels_ = levels;
   }
+
+  double getMacroMaxDiameter() const { return macroMaxDiameter_; }
+  void setMacroMaxDiameter(double distance)
+  {
+    macroMaxDiameter_ = distance;
+    macroMaxDiameterSet_ = true;
+  }
+  bool isMacroMaxDiameterSet() const { return macroMaxDiameterSet_; }
+  unsigned getMacroSinkClusteringSize() const { return macroSinkClustersSize_; }
+  void setMacroClusteringSize(unsigned size)
+  {
+    macroSinkClustersSize_ = size;
+    macroSinkClustersSizeSet_ = true;
+  }
+  bool isMacroSinkClusteringSizeSet() const
+  {
+    return macroSinkClustersSizeSet_;
+  }
   unsigned getNumStaticLayers() const { return numStaticLayers_; }
   void setBalanceLevels(bool balance) { balanceLevels_ = balance; }
   bool getBalanceLevels() const { return balanceLevels_; }
@@ -282,6 +300,10 @@ class CtsOptions : public odb::dbBlockCallBackObj
   bool maxDiameterSet_ = false;
   unsigned sinkClustersSize_ = 20;
   bool sinkClustersSizeSet_ = false;
+  double macroMaxDiameter_ = 50;
+  bool macroMaxDiameterSet_ = false;
+  unsigned macroSinkClustersSize_ = 4;
+  bool macroSinkClustersSizeSet_ = true;
   bool balanceLevels_ = false;
   unsigned sinkClusteringLevels_ = 0;
   unsigned numStaticLayers_ = 0;

src/cts/src/HTreeBuilder.cpp

@@ -30,6 +30,17 @@ void HTreeBuilder::preSinkClustering(
     const unsigned clusterSize,
     const bool secondLevel)
 {
+  bool maxDiameterSet = (type_ == TreeType::MacroTree)
+                            ? options_->isMacroMaxDiameterSet()
+                            : options_->isMaxDiameterSet();
+  unsigned clusterSizeSet = (type_ == TreeType::MacroTree)
+                                ? options_->isMacroSinkClusteringSizeSet()
+                                : options_->isSinkClusteringSizeSet();
+
+  unsigned min_clustering_sinks = (type_ == TreeType::MacroTree)
+                                      ? min_clustering_macro_sinks_
+                                      : min_clustering_sinks_;
+
   const std::vector<std::pair<float, float>>& points = sinks;
   if (!secondLevel) {
     clock_.forEachSink([&](ClockInst& inst) {
@@ -48,7 +59,7 @@ void HTreeBuilder::preSinkClustering(
     });
   }
 
-  if (sinks.size() <= min_clustering_sinks_
+  if (sinks.size() <= min_clustering_sinks
       || !(options_->getSinkClustering())) {
     topLevelSinksClustered_ = sinks;
     return;
@@ -70,32 +81,30 @@ void HTreeBuilder::preSinkClustering(
 
   unsigned bestClusterSize = 0;
   float bestDiameter = 0.0;
-  if (options_->isSinkClusteringSizeSet() && options_->isMaxDiameterSet()) {
+  if (clusterSizeSet && maxDiameterSet) {
     // clang-format off
       debugPrint(logger_, CTS, "clustering", 1, "**** match.run({}, {}, {}) ****",
-                 clusterSize, options_->getMaxDiameter(), wireSegmentUnit_);
+                 clusterSize, maxDiameter, wireSegmentUnit_);
     // clang-format on
     matching.run(clusterSize,
                  maxDiameter,
                  wireSegmentUnit_,
                  bestClusterSize,
                  bestDiameter);
-  } else if (!options_->isSinkClusteringSizeSet()
-             && options_->isMaxDiameterSet()) {
+  } else if (!clusterSizeSet && maxDiameterSet) {
     // only diameter is set, try clustering sizes of 10, 20 and 30
     for (unsigned clusterSize2 : clusterSizes()) {
       // clang-format off
       debugPrint(logger_, CTS, "clustering", 1, "**** match.run({}, {}, {}) ****",
-                 clusterSize2, options_->getMaxDiameter(), wireSegmentUnit_);
+                 clusterSize2, maxDiameter, wireSegmentUnit_);
       // clang-format on
       matching.run(clusterSize2,
                    maxDiameter,
                    wireSegmentUnit_,
                    bestClusterSize,
                    bestDiameter);
     }
-  } else if (options_->isSinkClusteringSizeSet()
-             && !options_->isMaxDiameterSet()) {
+  } else if (clusterSizeSet && !maxDiameterSet) {
     // only clustering size is set, try diameters of 50, 100 and 200 um
     for (unsigned clusterDiameter2 : clusterDiameters()) {
       // clang-format off
@@ -130,7 +139,7 @@ void HTreeBuilder::preSinkClustering(
     }
   }
 
-  if (options_->isSinkClusteringSizeSet() || options_->isMaxDiameterSet()) {
+  if (clusterSizeSet || maxDiameterSet) {
     logger_->info(
         CTS,
         204,
@@ -240,6 +249,16 @@ void HTreeBuilder::initSinkRegion()
   const int dbUnits = options_->getDbUnits();
   wireSegmentUnit_ = wireSegmentUnitInDbu;
 
+  double clusterDiameter = (type_ == TreeType::MacroTree)
+                               ? options_->getMacroMaxDiameter()
+                               : options_->getMaxDiameter();
+  unsigned clusterSize = (type_ == TreeType::MacroTree)
+                             ? options_->getMacroSinkClusteringSize()
+                             : options_->getSinkClusteringSize();
+  unsigned min_clustering_sinks = (type_ == TreeType::MacroTree)
+                                      ? min_clustering_macro_sinks_
+                                      : min_clustering_sinks_;
+
   logger_->info(CTS,
                 20,
                 " Wire segment unit: {}  dbu ({} um).",
@@ -270,18 +289,16 @@ void HTreeBuilder::initSinkRegion()
   std::vector<const ClockInst*> sinkInsts;
   initTopLevelSinks(topLevelSinks, sinkInsts);
 
-  const float maxDiameter
-      = (options_->getMaxDiameter() * dbUnits) / wireSegmentUnit_;
+  const float maxDiameter = (clusterDiameter * dbUnits) / wireSegmentUnit_;
   // clang-format off
   debugPrint(logger_, CTS, "clustering", 1, "maxDiameter={:0.3f} = "
              "origMaxDiam={} * dbUnits={} / wireSegmentUnit_={}",
-             maxDiameter, options_->getMaxDiameter(), dbUnits,
+             maxDiameter, clusterDiameter, dbUnits,
              wireSegmentUnit_);
   // clang-format on
 
-  preSinkClustering(
-      topLevelSinks, sinkInsts, maxDiameter, options_->getSinkClusteringSize());
-  if (topLevelSinks.size() <= min_clustering_sinks_
+  preSinkClustering(topLevelSinks, sinkInsts, maxDiameter, clusterSize);
+  if (topLevelSinks.size() <= min_clustering_sinks
       || !(options_->getSinkClustering())) {
     Box<int> sinkRegionDbu = clock_.computeSinkRegion();
     logger_->info(CTS, 23, " Original sink region: {}.", sinkRegionDbu);
@@ -296,7 +313,7 @@ void HTreeBuilder::initSinkRegion()
       preSinkClustering(secondLevelLocs,
                         secondLevelInsts,
                         maxDiameter * 4,
-                        std::ceil(std::sqrt(options_->getSinkClusteringSize())),
+                        std::ceil(std::sqrt(clusterSize)),
                         true);
     }
     sinkRegion_ = clock_.computeSinkRegionClustered(topLevelSinksClustered_);
@@ -963,11 +980,13 @@ void HTreeBuilder::legalizeDummy()
       Point<double>& branchPoint = topology.getBranchingPoint(idx);
       unsigned parentIdx = topology.getBranchingPointParentIdx(idx);
 
+      // clang-format off
       Point<double> parentPoint
           = (levelIdx == 0)
                 ? topLevelBufferLoc
                 : topologyForEachLevel_[levelIdx - 1].getBranchingPoint(
                       parentIdx);
+      // clang-format on
 
       const std::vector<Point<double>>& sinks
           = topology.getBranchSinksLocations(idx);
@@ -1049,11 +1068,13 @@ void HTreeBuilder::legalize()
       Point<double>& branchPoint = topology.getBranchingPoint(bufferIdx);
       unsigned parentIdx = topology.getBranchingPointParentIdx(bufferIdx);
 
+      // clang-format off
       Point<double> parentPoint
           = (levelIdx == 0)
                 ? newTopBufferLoc
                 : topologyForEachLevel_[levelIdx - 1].getBranchingPoint(
                       parentIdx);
+      // clang-format on
 
       odb::Direction2D::Value branch_point_dir;
       if (isHorizontal(levelIdx + 1)) {
@@ -1150,20 +1171,32 @@ void HTreeBuilder::legalize()
 
 void HTreeBuilder::run()
 {
+  double clusterDiameter = (type_ == TreeType::MacroTree)
+                               ? options_->getMacroMaxDiameter()
+                               : options_->getMaxDiameter();
+  unsigned clusterSize = (type_ == TreeType::MacroTree)
+                             ? options_->getMacroSinkClusteringSize()
+                             : options_->getSinkClusteringSize();
+  bool useMaxCap = (type_ == TreeType::MacroTree)
+                       ? false
+                       : options_->getSinkClusteringUseMaxCap();
+
   logger_->info(
       CTS, 27, "Generating H-Tree topology for net {}.", clock_.getName());
   logger_->info(CTS, 28, " Total number of sinks: {}.", clock_.getNumSinks());
   if (options_->getSinkClustering()) {
-    if (options_->getSinkClusteringUseMaxCap()) {
+    if (useMaxCap) {
       logger_->info(
           CTS, 90, " Sinks will be clustered based on buffer max cap.");
     } else {
-      logger_->info(CTS,
-                    29,
-                    " Sinks will be clustered in groups of up to {} and with "
-                    "maximum cluster diameter of {:.1f} um.",
-                    options_->getSinkClusteringSize(),
-                    options_->getMaxDiameter());
+      logger_->info(
+          CTS,
+          29,
+          " {} sinks will be clustered in groups of up to {} and with "
+          "maximum cluster diameter of {:.1f} um.",
+          type_ == TreeType::MacroTree ? "Macro " : "Register",
+          clusterSize,
+          clusterDiameter);
     }
   }
   logger_->info(
@@ -1258,6 +1291,7 @@ std::string HTreeBuilder::plotHTree()
   for (int levelIdx = 0; levelIdx < topologyForEachLevel_.size(); ++levelIdx) {
     LevelTopology& topology = topologyForEachLevel_[levelIdx];
 
+    // clang-format off
     topology.forEachBranchingPoint(
         [&](unsigned idx, Point<double> branchPoint) {
           unsigned parentIdx = topology.getBranchingPointParentIdx(idx);
@@ -1281,6 +1315,7 @@ std::string HTreeBuilder::plotHTree()
           file << levelIdx << " " << x1 << " " << y1 << " " << x2 << " " << y2;
           file << " " << name << '\n';
         });
+    // clang-format on
   }
 
   LevelTopology& leafTopology = topologyForEachLevel_.back();
@@ -1309,8 +1344,11 @@ std::string HTreeBuilder::plotHTree()
 unsigned HTreeBuilder::computeNumberOfSinksPerSubRegion(
     const unsigned level) const
 {
+  unsigned min_clustering_sinks = (type_ == TreeType::MacroTree)
+                                      ? min_clustering_macro_sinks_
+                                      : min_clustering_sinks_;
   unsigned totalNumSinks = 0;
-  if (clock_.getNumSinks() > min_clustering_sinks_
+  if (clock_.getNumSinks() > min_clustering_sinks
       && options_->getSinkClustering()) {
     totalNumSinks = topLevelSinksClustered_.size();
   } else {
@@ -2052,11 +2090,13 @@ void HTreeBuilder::printHTree()
       Point<double>& branchPoint = topology.getBranchingPoint(idx);
       unsigned parentIdx = topology.getBranchingPointParentIdx(idx);
 
+      // clang-format off
       Point<double> parentPoint
           = (levelIdx == 0)
                 ? topLevelBufferLoc
                 : topologyForEachLevel_[levelIdx - 1].getBranchingPoint(
                       parentIdx);
+      // clang-format on
 
       const std::vector<Point<double>>& sinks
           = topology.getBranchSinksLocations(idx);

src/cts/src/HTreeBuilder.h

@@ -372,6 +372,7 @@ class HTreeBuilder : public TreeBuilder
   unsigned minLengthSinkRegion_ = 0;
   unsigned clockTreeMaxDepth_ = 0;
   static constexpr int min_clustering_sinks_ = 200;
+  static constexpr int min_clustering_macro_sinks_ = 10;
   std::vector<unsigned> clusterDiameters_ = {50, 100, 200};
   std::vector<unsigned> clusterSizes_ = {10, 20, 30};
 };

src/cts/src/SinkClustering.cpp

@@ -31,7 +31,9 @@ SinkClustering::SinkClustering(const CtsOptions* options,
       techChar_(techChar),
       maxInternalDiameter_(10),
       capPerUnit_(0.0),
-      useMaxCapLimit_(options->getSinkClusteringUseMaxCap()),
+      useMaxCapLimit_((HTree->getTreeType() == TreeType::MacroTree)
+                          ? false
+                          : options->getSinkClusteringUseMaxCap()),
       scaleFactor_(1),
       HTree_(HTree)
 {

src/cts/src/TreeBuilder.cpp

@@ -26,16 +26,28 @@ void TreeBuilder::mergeBlockages()
   namespace gtl = boost::polygon;
   using boost::polygon::operators::operator+=;
 
+  uint macros_max_dx = 0, macros_max_dy = 0;
   odb::dbBlock* block = db_->getChip()->getBlock();
   gtl::polygon_90_set_data<int> blockage_polygons;
   // Add the macros into the polygon set
   for (odb::dbInst* inst : block->getInsts()) {
     if (inst->getMaster()->getType().isBlock()
         && inst->getPlacementStatus().isPlaced()) {
+      macros_max_dx = std::max(macros_max_dx, inst->getBBox()->getDX());
+      macros_max_dy = std::max(macros_max_dy, inst->getBBox()->getDY());
       blockage_polygons += inst->getBBox()->getBox();
     }
   }
 
+  // Set macros clustering diameter as 2 * macros highest dimention.
+  double max_diameter
+      = block->dbuToMicrons(2 * std::max(macros_max_dx, macros_max_dy));
+
+  if (max_diameter && !options_->isMacroMaxDiameterSet()) {
+    options_->setMacroMaxDiameter(
+        std::max(max_diameter, options_->getMacroMaxDiameter()));
+  }
+
   // Add the hard blockages into the polygon set
   for (odb::dbBlockage* blockage : block->getBlockages()) {
     if (!blockage->isSoft()) {

src/cts/src/TritonCTS.cpp

@@ -1187,6 +1187,7 @@ bool TritonCTS::separateMacroRegSinks(
       }
     }
   }
+
   return true;
 }
 

src/cts/src/TritonCTS.i

@@ -144,6 +144,18 @@ set_clustering_diameter(double distance)
   getTritonCts()->getParms()->setMaxDiameter(distance);
 }
 
+void
+set_macro_clustering_size(unsigned size)
+{
+  getTritonCts()->getParms()->setMacroClusteringSize(size);
+}
+
+void
+set_macro_clustering_diameter(double distance)
+{
+  getTritonCts()->getParms()->setMacroMaxDiameter(distance);
+}
+
 void
 set_num_static_layers(unsigned num)
 {