CTS: improve automatic clustering

src/cts/src/CtsOptions.cpp

@@ -35,10 +35,7 @@ void CtsOptions::limitSinkClusteringSizes(unsigned limit)
     setSinkClusteringSize(std::min(limit, sinkClustersSize_));
     return;
   }
-  auto lowerBound = std::lower_bound(
-      sinkClusteringSizes_.begin(), sinkClusteringSizes_.end(), limit);
-  sinkClusteringSizes_.erase(lowerBound, sinkClusteringSizes_.end());
-  sinkClusteringSizes_.push_back(limit);
+  sinkClustersSize_ = limit;
 }
 
 void CtsOptions::recordBuffer(odb::dbMaster* master, MasterType type)

src/cts/src/CtsOptions.h

@@ -219,10 +219,6 @@ class CtsOptions : public odb::dbBlockCallBackObj
     maxDiameterSet_ = false;
   }
   bool isMaxDiameterSet() const { return maxDiameterSet_; }
-  const std::vector<unsigned>& getSinkClusteringDiameters()
-  {
-    return sinkClusteringDiameters_;
-  }
   unsigned getSinkClusteringSize() const { return sinkClustersSize_; }
   void setSinkClusteringSize(unsigned size)
   {
@@ -232,15 +228,11 @@ class CtsOptions : public odb::dbBlockCallBackObj
   }
   void resetSinkClusteringSize()
   {
-    sinkClustersSize_ = 20;
+    sinkClustersSize_ = 30;
     sinkClusteringUseMaxCap_ = true;
     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)
@@ -390,10 +382,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

@@ -80,63 +80,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(

src/cts/src/SinkClustering.cpp

@@ -28,9 +28,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,7 +421,17 @@ bool SinkClustering::isLimitExceeded(const unsigned size,
                                      const unsigned sizeLimit)
 {
   if (useMaxCapLimit_) {
-    return (capCost > options_->getSinkBufferInputCap() * max_cap__factor_);
+    bool is_limit_exceeded
+        = (capCost > options_->getSinkBufferInputCap() * max_cap__factor_);
+    // 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;
   }
 
   return (size >= sizeLimit || cost > maxInternalDiameter_);

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;