Merge branch 'master' of https://github.com/The-OpenROAD-Project/OpenROAD into ppl_remove_random

Author: eder-matheus

docs/user/Bazel.md

@@ -339,3 +339,23 @@ Now start the bisection as usual with a bad and good commit from the above list:
 Use `git bisect --skip` if the version does not build or otherwise should not be tested.
 
 OpenSTA has an additional challenge in that only the https://github.com/The-OpenROAD-Project/OpenSTA fork has the Bazel BUILD file. To bisect the https://github.com/parallaxsw/OpenSTA branch, check out the branch you want, then check out BUILD from the fork and do a `git reset HEAD`. This will leave BUILD as a local file, because it is not in the upstream repository and bisection can be done on the upstream master branch.
+
+## Testing the GUI with gcd on a pull request by number
+
+To test a PR with the GUI on gcd, run:
+
+```
+    $ git fetch origin pull/7856/head
+    $ git checkout FETCH_HEAD
+    $ bazelisk run test/orfs/gcd:gcd_final /tmp/gcd -- gui_final
+```
+
+This will:
+
+- fetch and checkout pull request 7856
+- build OpenROAD
+- run bazel-orfs flow on gcd
+- create a /tmp/gcd folder with the ORFS project
+- launch the GUI opening gui_final gcd
+
+`bazelisk run test/orfs/gcd:gcd_final` run alone would create the `/tmp/gcd` folder and the arguments. The arguments after `--` are forwarded to the `/tmp/gcd/make` script that invokes make with the gcd ORFS project set up in `/tmp/gcd/_main/config.mk`.

src/gui/include/gui/gui.h

@@ -691,7 +691,8 @@ class Gui
                           const std::string& corner = "",
                           int width_px = 0,
                           int height_px = 0);
-  void selectClockviewerClock(const std::string& clock_name);
+  void selectClockviewerClock(const std::string& clock_name,
+                              std::optional<int> depth);
 
   // Save histogram view
   void saveHistogramImage(const std::string& filename,

src/gui/src/chartsWidget.cpp

@@ -530,9 +530,23 @@ void HistogramView::clear()
 void HistogramView::showToolTip(bool is_hovering, int bar_index)
 {
   if (is_hovering) {
+    int num;
+    if (buckets_.negative.empty()) {
+      num = buckets_.positive[bar_index].size();
+    } else {
+      const int num_of_neg_buckets = static_cast<int>(buckets_.negative.size());
+
+      if (bar_index >= num_of_neg_buckets) {
+        num = buckets_.positive[bar_index - num_of_neg_buckets].size();
+        ;
+      } else {
+        num = buckets_.negative[bar_index].size();
+        ;
+      }
+    }
+
     const QString number_of_pins
-        = QString("Number of Endpoints: %1\n")
-              .arg(static_cast<QBarSet*>(sender())->at(bar_index));
+        = QString("Number of Endpoints: %1\n").arg(num);
 
     QString scaled_suffix = sta_->getSTA()->units()->timeUnit()->scaledSuffix();
 
@@ -712,16 +726,22 @@ void HistogramView::setVisualConfig()
     return;
   }
 
-  std::pair<QBarSet*, QBarSet*> bar_sets = createBarSets(); /* <neg, pos> */
-  populateBarSets(*bar_sets.first, *bar_sets.second);
+  std::tuple<QBarSet*, QBarSet*, QBarSet*, QBarSet*> bar_sets
+      = createBarSets(); /* <neg, pos> */
+  populateBarSets(*std::get<0>(bar_sets),
+                  *std::get<1>(bar_sets),
+                  *std::get<2>(bar_sets),
+                  *std::get<3>(bar_sets));
 
   QStackedBarSeries* series = new QStackedBarSeries(this);
-  series->append(bar_sets.first);
-  series->append(bar_sets.second);
+  series->append(std::get<0>(bar_sets));
+  series->append(std::get<1>(bar_sets));
+  series->append(std::get<2>(bar_sets));
+  series->append(std::get<3>(bar_sets));
   series->setBarWidth(1.0);
   chart_->addSeries(series);
 
-  setXAxisConfig(bar_sets.first->count());
+  setXAxisConfig(std::get<0>(bar_sets)->count());
   setYAxisConfig();
   series->attachAxis(axis_y_);
 
@@ -732,24 +752,43 @@ void HistogramView::setVisualConfig()
   chart_->setTitle("Endpoint Slack");
 }
 
-std::pair<QBarSet*, QBarSet*> HistogramView::createBarSets()
+std::tuple<QBarSet*, QBarSet*, QBarSet*, QBarSet*>
+HistogramView::createBarSets()
 {
   QBarSet* neg_set = new QBarSet("");
   neg_set->setBorderColor(0x8b0000);  // darkred
   neg_set->setColor(0xf08080);        // lightcoral
   QBarSet* pos_set = new QBarSet("");
   pos_set->setBorderColor(0x006400);  // darkgreen
   pos_set->setColor(0x90ee90);        // lightgreen
+  QBarSet* pos_set_invisible = new QBarSet("");
+  pos_set_invisible->setBorderColor(Qt::transparent);
+  pos_set_invisible->setColor(Qt::transparent);
+  QBarSet* neg_set_invisible = new QBarSet("");
+  neg_set_invisible->setBorderColor(Qt::transparent);
+  neg_set_invisible->setColor(Qt::transparent);
 
   connect(neg_set, &QBarSet::hovered, this, &HistogramView::showToolTip);
   connect(pos_set, &QBarSet::hovered, this, &HistogramView::showToolTip);
+  connect(
+      pos_set_invisible, &QBarSet::hovered, this, &HistogramView::showToolTip);
+  connect(
+      neg_set_invisible, &QBarSet::hovered, this, &HistogramView::showToolTip);
 
   connect(
       neg_set, &QBarSet::clicked, this, &HistogramView::emitEndPointsInBucket);
   connect(
       pos_set, &QBarSet::clicked, this, &HistogramView::emitEndPointsInBucket);
+  connect(pos_set_invisible,
+          &QBarSet::clicked,
+          this,
+          &HistogramView::emitEndPointsInBucket);
+  connect(neg_set_invisible,
+          &QBarSet::clicked,
+          this,
+          &HistogramView::emitEndPointsInBucket);
 
-  return {neg_set, pos_set};
+  return {neg_set, pos_set, pos_set_invisible, neg_set_invisible};
 }
 
 void HistogramView::emitEndPointsInBucket(const int bar_index)
@@ -915,15 +954,23 @@ int HistogramView::computeFirstDigit(int value, int digits)
   return static_cast<int>(value / std::pow(10, digits - 1));
 }
 
-void HistogramView::populateBarSets(QBarSet& neg_set, QBarSet& pos_set)
+void HistogramView::populateBarSets(QBarSet& neg_set,
+                                    QBarSet& pos_set,
+                                    QBarSet& neg_set_invisible,
+                                    QBarSet& pos_set_invisible)
 {
+  const int max_bin_count = histogram_->getMaxBinCount();
   for (const auto& bucket : buckets_.negative) {
     neg_set << bucket.size();
+    neg_set_invisible << max_bin_count - bucket.size();
     pos_set << 0;
+    pos_set_invisible << 0;
   }
   for (const auto& bucket : buckets_.positive) {
     neg_set << 0;
+    neg_set_invisible << 0;
     pos_set << bucket.size();
+    pos_set_invisible << max_bin_count - bucket.size();
   }
 }
 

src/gui/src/chartsWidget.h

@@ -82,8 +82,11 @@ class HistogramView : public QChartView
       const std::vector<std::vector<const sta::Pin*>>& pin_bins);
   void setVisualConfig();
 
-  std::pair<QBarSet*, QBarSet*> createBarSets();
-  void populateBarSets(QBarSet& neg_set, QBarSet& pos_set);
+  std::tuple<QBarSet*, QBarSet*, QBarSet*, QBarSet*> createBarSets();
+  void populateBarSets(QBarSet& neg_set,
+                       QBarSet& pos_set,
+                       QBarSet& neg_set_invisible,
+                       QBarSet& pos_set_invisible);
 
   void setXAxisConfig(int all_bars_count);
   void setXAxisTitle();

src/gui/src/clockWidget.cpp

@@ -152,6 +152,10 @@ void ClockTreeRenderer::resetTree()
 
 void ClockTreeRenderer::setMaxColorDepth(int depth)
 {
+  if (depth < 1) {
+    return;
+  }
+
   max_depth_ = depth;
   redraw();
 }
@@ -1651,7 +1655,8 @@ void ClockWidget::postReadLiberty()
   }
 }
 
-void ClockWidget::selectClock(const std::string& clock_name)
+void ClockWidget::selectClock(const std::string& clock_name,
+                              std::optional<int> depth)
 {
   setVisible(true);
 
@@ -1662,6 +1667,9 @@ void ClockWidget::selectClock(const std::string& clock_name)
   for (auto& view : views_) {
     if (view->getClockName() == clock_name) {
       clocks_tab_->setCurrentWidget(view.get());
+      if (depth) {
+        view->updateColorDepth(*depth);
+      }
 
       return;
     }

src/gui/src/clockWidget.h

@@ -404,12 +404,12 @@ class ClockTreeView : public QGraphicsView
   void setRendererState(RendererState state);
   void fit();
   void save(const QString& path = "");
+  void updateColorDepth(int depth);
 
  private slots:
   void selectionChanged();
   void highlightTo(odb::dbITerm* term);
   void clearHighlightTo();
-  void updateColorDepth(int depth);
 
  protected:
   void wheelEvent(QWheelEvent* event) override;
@@ -516,7 +516,8 @@ class ClockWidget : public QDockWidget, sta::dbNetworkObserver
                  const std::string& corner,
                  const std::optional<int>& width_px,
                  const std::optional<int>& height_px);
-  void selectClock(const std::string& clock_name);
+  void selectClock(const std::string& clock_name,
+                   std::optional<int> depth = {});
 
   void postReadLiberty() override;
 

src/gui/src/gui.cpp

@@ -832,12 +832,13 @@ void Gui::saveHistogramImage(const std::string& filename,
       filename, chart_mode, width, height);
 }
 
-void Gui::selectClockviewerClock(const std::string& clock_name)
+void Gui::selectClockviewerClock(const std::string& clock_name,
+                                 std::optional<int> depth)
 {
   if (!enabled()) {
     return;
   }
-  main_window->getClockViewer()->selectClock(clock_name);
+  main_window->getClockViewer()->selectClock(clock_name, depth);
 }
 
 static QWidget* findWidget(const std::string& name)

src/gui/src/gui.i

@@ -310,13 +310,17 @@ void save_clocktree_image(const char* filename, const char* clock_name, const ch
   gui->saveClockTreeImage(clock_name, filename, corner, width_px, height_px);
 }
 
-void select_clockviewer_clock(const char* clock_name)
+void select_clockviewer_clock(const char* clock_name, int depth = 0)
 {
   if (!check_gui("select_clockviewer_clock")) {
     return;
   }
   auto gui = gui::Gui::get();
-  gui->selectClockviewerClock(clock_name);
+  std::optional<int> clock_depth;
+  if (depth > 0) {
+    clock_depth = depth;
+  }
+  gui->selectClockviewerClock(clock_name, clock_depth);
 }
 
 void save_histogram_image(const char* filename, const char* mode, int width_px = 0, int height_px = 0)

src/mpl/src/clusterEngine.cpp

@@ -311,6 +311,21 @@ void ClusteringEngine::setBaseThresholds()
 {
   if (tree_->base_max_macro <= 0 || tree_->base_min_macro <= 0
       || tree_->base_max_std_cell <= 0 || tree_->base_min_std_cell <= 0) {
+    // From original implementation: Reset maximum level based on number
+    // of macros.
+    const int min_num_macros_for_multilevel = 150;
+    if (design_metrics_->getNumMacro() <= min_num_macros_for_multilevel) {
+      tree_->max_level = 1;
+      debugPrint(
+          logger_,
+          MPL,
+          "multilevel_autoclustering",
+          1,
+          "Number of macros is below {}. Resetting number of levels to {}",
+          min_num_macros_for_multilevel,
+          tree_->max_level);
+    }
+
     // Set base values for std cell lower/upper thresholds
     const int min_num_std_cells_allowed = 1000;
     tree_->base_min_std_cell
@@ -331,21 +346,6 @@ void ClusteringEngine::setBaseThresholds()
     }
     tree_->base_max_macro
         = tree_->base_min_macro * tree_->cluster_size_ratio / 2.0;
-
-    // From original implementation: Reset maximum level based on number
-    // of macros.
-    const int min_num_macros_for_multilevel = 150;
-    if (design_metrics_->getNumMacro() <= min_num_macros_for_multilevel) {
-      tree_->max_level = 1;
-      debugPrint(
-          logger_,
-          MPL,
-          "multilevel_autoclustering",
-          1,
-          "Number of macros is below {}. Resetting number of levels to {}",
-          min_num_macros_for_multilevel,
-          tree_->max_level);
-    }
   }
 
   // Set sizes for root
@@ -1978,14 +1978,7 @@ void ClusteringEngine::breakMixedLeaves(
 //               A1  A2  A3
 void ClusteringEngine::breakMixedLeaf(Cluster* mixed_leaf)
 {
-  Cluster* parent = mixed_leaf;
-  const float macro_dominated_cluster_ratio = 0.01;
-
-  // Split by replacement if macro dominated.
-  if (mixed_leaf->getNumStdCell() * macro_dominated_cluster_ratio
-      < mixed_leaf->getNumMacro()) {
-    parent = mixed_leaf->getParent();
-  }
+  Cluster* parent = mixed_leaf->getParent();
 
   mapMacroInCluster2HardMacro(mixed_leaf);
 
@@ -2027,12 +2020,7 @@ void ClusteringEngine::breakMixedLeaf(Cluster* mixed_leaf)
   // Never use SetInstProperty in the following lines for the reason above!
   std::vector<int> virtual_conn_clusters;
 
-  // Deal with the std cells
-  if (parent == mixed_leaf) {
-    addStdCellClusterToSubTree(parent, mixed_leaf, virtual_conn_clusters);
-  } else {
-    replaceByStdCellCluster(mixed_leaf, virtual_conn_clusters);
-  }
+  replaceByStdCellCluster(mixed_leaf, virtual_conn_clusters);
 
   // Deal with the macros
   for (int i = 0; i < macro_class.size(); i++) {
@@ -2256,29 +2244,6 @@ void ClusteringEngine::groupSingleMacroClusters(
   }
 }
 
-void ClusteringEngine::addStdCellClusterToSubTree(
-    Cluster* parent,
-    Cluster* mixed_leaf,
-    std::vector<int>& virtual_conn_clusters)
-{
-  std::string std_cell_cluster_name = mixed_leaf->getName();
-  auto std_cell_cluster
-      = std::make_unique<Cluster>(id_, std_cell_cluster_name, logger_);
-
-  std_cell_cluster->copyInstances(*mixed_leaf);
-  std_cell_cluster->clearLeafMacros();
-  std_cell_cluster->setClusterType(StdCellCluster);
-
-  setClusterMetrics(std_cell_cluster.get());
-
-  virtual_conn_clusters.push_back(std_cell_cluster->getId());
-
-  tree_->maps.id_to_cluster[id_++] = std_cell_cluster.get();
-  std_cell_cluster->setParent(parent);
-  parent->addChild(std::move(std_cell_cluster));
-}
-
-// We don't modify the physical hierarchy when spliting by replacement
 void ClusteringEngine::replaceByStdCellCluster(
     Cluster* mixed_leaf,
     std::vector<int>& virtual_conn_clusters)

src/mpl/src/clusterEngine.h

@@ -230,9 +230,6 @@ class ClusteringEngine
                                 const std::vector<int>& signature_class,
                                 std::vector<int>& interconn_class,
                                 std::vector<int>& macro_class);
-  void addStdCellClusterToSubTree(Cluster* parent,
-                                  Cluster* mixed_leaf,
-                                  std::vector<int>& virtual_conn_clusters);
   void replaceByStdCellCluster(Cluster* mixed_leaf,
                                std::vector<int>& virtual_conn_clusters);