Merge branch 'The-OpenROAD-Project:master' into gui-drc

Author: LucasYuki

MODULE.bazel

@@ -162,7 +162,7 @@ bazel_dep(name = "bazel-orfs")
 # To bump version, run: bazelisk run @bazel-orfs//:bump
 git_override(
     module_name = "bazel-orfs",
-    commit = "60f7488a0480dc8f17aba1d28da18f0b3e777f73",
+    commit = "b2ea891b7a20e806f7a80b97523b9065d498b3ac",
     remote = "https://github.com/The-OpenROAD-Project/bazel-orfs.git",
 )
 
@@ -171,10 +171,10 @@ orfs = use_extension("@bazel-orfs//:extension.bzl", "orfs_repositories")
 # To bump version, run: bazelisk run @bazel-orfs//:bump
 orfs.default(
     # Official image https://hub.docker.com/r/openroad/orfs/tags
-    image = "docker.io/openroad/orfs:v3.0-4324-g16e8a645e",
+    image = "docker.io/openroad/orfs:v3.0-4338-g23bfbc7f2",
     # Use OpenROAD of this repo instead of from the docker image
     openroad = "//:openroad",
-    sha256 = "675813db8a9fbfd08bc86e40675c2a376fc3461b59cbf22d96a2f1905dbb4519",
+    sha256 = "59fa14cf42c9d2ebf388e77e45cee79ba1ae7dae24cf7fe8a004d6b37d160968",
 )
 use_repo(orfs, "com_github_nixos_patchelf_download")
 use_repo(orfs, "docker_orfs")

MODULE.bazel.lock

@@ -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.cc

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

src/cts/src/CtsOptions.cpp

@@ -84,6 +84,11 @@ 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; }
@@ -204,26 +209,38 @@ 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_ = 30;
+    sinkClustersSize_ = 20;
+    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)
@@ -346,6 +363,7 @@ 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_;
@@ -372,8 +390,10 @@ class CtsOptions : public odb::dbBlockCallBackObj
   int sinks_ = 0;
   double maxDiameter_ = 50;
   bool maxDiameterSet_ = false;
-  unsigned sinkClustersSize_ = 30;
+  std::vector<unsigned> sinkClusteringDiameters_ = {50, 100, 200};
+  unsigned sinkClustersSize_ = 20;
   bool sinkClustersSizeSet_ = false;
+  std::vector<unsigned> sinkClusteringSizes_ = {10, 20, 30};
   double macroMaxDiameter_ = 50;
   bool macroMaxDiameterSet_ = false;
   unsigned macroSinkClustersSize_ = 4;

src/cts/src/CtsOptions.h

@@ -80,15 +80,63 @@ void HTreeBuilder::preSinkClustering(
 
   unsigned bestClusterSize = 0;
   float bestDiameter = 0.0;
-  // 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) {
+    // 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);
+      }
+    }
+  }
 
   if (clusterSizeSet || maxDiameterSet) {
     logger_->info(
@@ -1128,21 +1176,18 @@ 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
-                       : !(use_max_size && use_max_diameter);
+                       : 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 (!useMaxCap) {
+    if (useMaxCap) {
+      logger_->info(
+          CTS, 90, " Sinks will be clustered based on buffer max cap.");
+    } else {
       logger_->info(
           CTS,
           29,
@@ -1151,23 +1196,6 @@ 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/HTreeBuilder.cpp

@@ -12,7 +12,6 @@
 #include <sstream>
 #include <vector>
 
-#include "TreeBuilder.h"
 #include "stt/SteinerTreeBuilder.h"
 #include "utl/Logger.h"
 
@@ -29,15 +28,9 @@ 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
-                          : !(use_max_size_ && use_max_diameter_)),
+                          : options->getSinkClusteringUseMaxCap()),
       scaleFactor_(1),
       HTree_(HTree)
 {
@@ -421,20 +414,11 @@ bool SinkClustering::isLimitExceeded(const unsigned size,
                                      const double capCost,
                                      const unsigned sizeLimit)
 {
-  bool is_limit_exceeded = false;
   if (useMaxCapLimit_) {
-    is_limit_exceeded
-        |= (capCost > options_->getSinkBufferInputCap() * max_cap__factor_);
+    return (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_);
 }
 
 void SinkClustering::writePlotFile(unsigned groupSize)

src/cts/src/SinkClustering.cpp

@@ -90,8 +90,6 @@ 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;