cts: restore automatic clustering PR

src/cts/src/CtsOptions.cpp

@@ -31,14 +31,11 @@ void CtsOptions::inDbInstCreate(odb::dbInst* inst, odb::dbRegion* region)
 
 void CtsOptions::limitSinkClusteringSizes(unsigned limit)
 {
+  unsigned new_size = limit;
   if (sinkClustersSizeSet_) {
-    setSinkClusteringSize(std::min(limit, sinkClustersSize_));
-    return;
+    new_size = std::min(new_size, sinkClustersSize_);
   }
-  auto lowerBound = std::lower_bound(
-      sinkClusteringSizes_.begin(), sinkClusteringSizes_.end(), limit);
-  sinkClusteringSizes_.erase(lowerBound, sinkClusteringSizes_.end());
-  sinkClusteringSizes_.push_back(limit);
+  setSinkClusteringSize(new_size);
 }
 
 void CtsOptions::recordBuffer(odb::dbMaster* master, MasterType type)

src/cts/src/CtsOptions.h

@@ -84,11 +84,6 @@ class CtsOptions : public odb::dbBlockCallBackObj
 
   void setSinkClustering(bool enable) { sinkClusteringEnable_ = enable; }
   bool getSinkClustering() const { return sinkClusteringEnable_; }
-  void setSinkClusteringUseMaxCap(bool useMaxCap)
-  {
-    sinkClusteringUseMaxCap_ = useMaxCap;
-  }
-  bool getSinkClusteringUseMaxCap() const { return sinkClusteringUseMaxCap_; }
   void setNumMaxLeafSinks(unsigned numSinks) { numMaxLeafSinks_ = numSinks; }
   unsigned getNumMaxLeafSinks() const { return numMaxLeafSinks_; }
   void setMaxSlew(unsigned slew) { maxSlew_ = slew; }
@@ -209,38 +204,26 @@ class CtsOptions : public odb::dbBlockCallBackObj
   void setMaxDiameter(double distance)
   {
     maxDiameter_ = distance;
-    sinkClusteringUseMaxCap_ = false;
     maxDiameterSet_ = true;
   }
   void resetMaxDiameter()
   {
     maxDiameter_ = 50;
-    sinkClusteringUseMaxCap_ = true;
     maxDiameterSet_ = false;
   }
   bool isMaxDiameterSet() const { return maxDiameterSet_; }
-  const std::vector<unsigned>& getSinkClusteringDiameters()
-  {
-    return sinkClusteringDiameters_;
-  }
   unsigned getSinkClusteringSize() const { return sinkClustersSize_; }
   void setSinkClusteringSize(unsigned size)
   {
     sinkClustersSize_ = size;
-    sinkClusteringUseMaxCap_ = false;
     sinkClustersSizeSet_ = true;
   }
   void resetSinkClusteringSize()
   {
-    sinkClustersSize_ = 20;
-    sinkClusteringUseMaxCap_ = true;
+    sinkClustersSize_ = 30;
     sinkClustersSizeSet_ = false;
   }
   bool isSinkClusteringSizeSet() const { return sinkClustersSizeSet_; }
-  const std::vector<unsigned>& getSinkClusteringSizes()
-  {
-    return sinkClusteringSizes_;
-  }
   void limitSinkClusteringSizes(unsigned limit);
   unsigned getSinkClusteringLevels() const { return sinkClusteringLevels_; }
   void setSinkClusteringLevels(unsigned levels)
@@ -363,7 +346,6 @@ class CtsOptions : public odb::dbBlockCallBackObj
   unsigned wireSegmentUnit_ = 0;
   bool plotSolution_ = false;
   bool sinkClusteringEnable_ = true;
-  bool sinkClusteringUseMaxCap_ = true;
   bool simpleSegmentsEnable_ = false;
   bool vertexBuffersEnable_ = false;
   std::unique_ptr<CtsObserver> observer_;
@@ -390,10 +372,8 @@ class CtsOptions : public odb::dbBlockCallBackObj
   int sinks_ = 0;
   double maxDiameter_ = 50;
   bool maxDiameterSet_ = false;
-  std::vector<unsigned> sinkClusteringDiameters_ = {50, 100, 200};
-  unsigned sinkClustersSize_ = 20;
+  unsigned sinkClustersSize_ = 30;
   bool sinkClustersSizeSet_ = false;
-  std::vector<unsigned> sinkClusteringSizes_ = {10, 20, 30};
   double macroMaxDiameter_ = 50;
   bool macroMaxDiameterSet_ = false;
   unsigned macroSinkClustersSize_ = 4;

src/cts/src/HTreeBuilder.cpp

@@ -81,63 +81,15 @@ void HTreeBuilder::preSinkClustering(
 
   unsigned bestClusterSize = 0;
   float bestDiameter = 0.0;
-  if (clusterSizeSet && maxDiameterSet) {
-    // clang-format off
-      debugPrint(logger_, CTS, "clustering", 1, "**** match.run({}, {}, {}) ****",
-                 clusterSize, maxDiameter, wireSegmentUnit_);
-    // clang-format on
-    matching.run(clusterSize,
-                 maxDiameter,
-                 wireSegmentUnit_,
-                 bestClusterSize,
-                 bestDiameter);
-  } else if (!clusterSizeSet && maxDiameterSet) {
-    // only diameter is set, try clustering sizes of 10, 20 and 30
-    for (unsigned clusterSize2 : options_->getSinkClusteringSizes()) {
-      // clang-format off
-      debugPrint(logger_, CTS, "clustering", 1, "**** match.run({}, {}, {}) ****",
-                 clusterSize2, maxDiameter, wireSegmentUnit_);
-      // clang-format on
-      matching.run(clusterSize2,
-                   maxDiameter,
-                   wireSegmentUnit_,
-                   bestClusterSize,
-                   bestDiameter);
-    }
-  } else if (clusterSizeSet && !maxDiameterSet) {
-    // only clustering size is set, try diameters of 50, 100 and 200 um
-    for (unsigned clusterDiameter2 : options_->getSinkClusteringDiameters()) {
-      // clang-format off
-      debugPrint(logger_, CTS, "clustering", 1, "**** match.run({}, {}, {}) ****",
-                 clusterSize, clusterDiameter2, wireSegmentUnit_);
-      // clang-format on
-      float maxDiameter2 = clusterDiameter2 * (float) options_->getDbUnits()
-                           / wireSegmentUnit_;
-      matching.run(clusterSize,
-                   maxDiameter2,
-                   wireSegmentUnit_,
-                   bestClusterSize,
-                   bestDiameter);
-    }
-  } else {  // neighther clustering size nor diameter is set
-    // try diameters of 50, 100 and 200 um
-    for (unsigned clusterDiameter2 : clusterDiameters()) {
-      // try clustering sizes of 10, 20 and 30
-      for (unsigned clusterSize2 : options_->getSinkClusteringSizes()) {
-        // clang-format off
-        debugPrint(logger_, CTS, "clustering", 1, "**** match.run({}, {}, {}) ****",
-                   clusterSize2, clusterDiameter2, wireSegmentUnit_);
-        // clang-format on
-        float maxDiameter2 = clusterDiameter2 * (float) options_->getDbUnits()
-                             / wireSegmentUnit_;
-        matching.run(clusterSize2,
-                     maxDiameter2,
-                     wireSegmentUnit_,
-                     bestClusterSize,
-                     bestDiameter);
-      }
-    }
-  }
+  // clang-format off
+  debugPrint(logger_, CTS, "clustering", 1, "**** match.run({}, {}, {}) ****",
+             clusterSize, maxDiameter, wireSegmentUnit_);
+  // clang-format on
+  matching.run(clusterSize,
+               maxDiameter,
+               wireSegmentUnit_,
+               bestClusterSize,
+               bestDiameter);
 
   if (clusterSizeSet || maxDiameterSet) {
     logger_->info(
@@ -1177,18 +1129,21 @@ void HTreeBuilder::run()
   unsigned clusterSize = (type_ == TreeType::MacroTree)
                              ? options_->getMacroSinkClusteringSize()
                              : options_->getSinkClusteringSize();
+  bool use_max_diameter = (type_ == TreeType::MacroTree)
+                              ? options_->isMacroMaxDiameterSet()
+                              : options_->isMaxDiameterSet();
+  bool use_max_size = (type_ == TreeType::MacroTree)
+                          ? options_->isMacroSinkClusteringSizeSet()
+                          : options_->isSinkClusteringSizeSet();
   bool useMaxCap = (type_ == TreeType::MacroTree)
                        ? false
-                       : options_->getSinkClusteringUseMaxCap();
+                       : !(use_max_size && use_max_diameter);
 
   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 (useMaxCap) {
-      logger_->info(
-          CTS, 90, " Sinks will be clustered based on buffer max cap.");
-    } else {
+    if (!useMaxCap) {
       logger_->info(
           CTS,
           29,
@@ -1197,6 +1152,23 @@ void HTreeBuilder::run()
           type_ == TreeType::MacroTree ? "Macro " : "Register",
           clusterSize,
           clusterDiameter);
+    } else if (use_max_diameter && !use_max_size) {
+      logger_->info(CTS,
+                    59,
+                    " {} sinks will be clustered with maximum cluster diameter "
+                    "of {:.1f} um and based on buffer max cap.",
+                    type_ == TreeType::MacroTree ? "Macro " : "Register",
+                    clusterDiameter);
+    } else if (!use_max_diameter && use_max_size) {
+      logger_->info(CTS,
+                    60,
+                    " {} sinks will be clustered in groups of up to {} and "
+                    "based on buffer max cap.",
+                    type_ == TreeType::MacroTree ? "Macro " : "Register",
+                    clusterSize);
+    } else {
+      logger_->info(
+          CTS, 90, " Sinks will be clustered based on buffer max cap.");
     }
   }
   logger_->info(

src/cts/src/SinkClustering.cpp

@@ -12,6 +12,7 @@
 #include <sstream>
 #include <vector>
 
+#include "TreeBuilder.h"
 #include "Util.h"
 #include "stt/SteinerTreeBuilder.h"
 #include "utl/Logger.h"
@@ -29,9 +30,15 @@ SinkClustering::SinkClustering(const CtsOptions* options,
       techChar_(techChar),
       maxInternalDiameter_(10),
       capPerUnit_(0.0),
+      use_max_diameter_((HTree->getTreeType() == TreeType::MacroTree)
+                            ? options->isMacroMaxDiameterSet()
+                            : options->isMaxDiameterSet()),
+      use_max_size_((HTree->getTreeType() == TreeType::MacroTree)
+                        ? options->isMacroSinkClusteringSizeSet()
+                        : options->isSinkClusteringSizeSet()),
       useMaxCapLimit_((HTree->getTreeType() == TreeType::MacroTree)
                           ? false
-                          : options->getSinkClusteringUseMaxCap()),
+                          : !(use_max_size_ && use_max_diameter_)),
       scaleFactor_(1),
       HTree_(HTree)
 {
@@ -415,11 +422,20 @@ bool SinkClustering::isLimitExceeded(const unsigned size,
                                      const double capCost,
                                      const unsigned sizeLimit)
 {
+  bool is_limit_exceeded = false;
   if (useMaxCapLimit_) {
-    return (capCost > options_->getSinkBufferInputCap() * max_cap__factor_);
+    is_limit_exceeded
+        |= (capCost > options_->getSinkBufferInputCap() * max_cap__factor_);
   }
-
-  return (size >= sizeLimit || cost > maxInternalDiameter_);
+  // size is defined by the user
+  if (use_max_size_) {
+    is_limit_exceeded |= (size >= sizeLimit);
+  }
+  // diameter is defined by the user
+  if (use_max_diameter_) {
+    is_limit_exceeded |= (cost > maxInternalDiameter_);
+  }
+  return is_limit_exceeded;
 }
 
 void SinkClustering::writePlotFile(unsigned groupSize)

src/cts/src/SinkClustering.h

@@ -90,6 +90,8 @@ class SinkClustering
   std::vector<std::vector<unsigned>> bestSolution_;
   float maxInternalDiameter_;
   float capPerUnit_;
+  bool use_max_diameter_;
+  bool use_max_size_;
   bool useMaxCapLimit_;
   int scaleFactor_;
   static constexpr double max_cap__factor_ = 10;