Merge branch 'master' of https://github.com/The-OpenROAD-Project-private/OpenSTA into secure-test-suite-cleanup

Signed-off-by: Jaehyun Kim <jhkim@precisioninno.com>

Author: jhkim-pii

.github/workflows/buildifier.yaml

@@ -25,11 +25,11 @@ jobs:
 
     steps:
       - name: Checkout Code
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
 
       - name: Cache buildifier
         id: cache-buildifier
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         with:
           path: ./buildifier
           key: ${{ runner.os }}-buildifier-${{ env.BUILDIFIER_VERSION }}

graph/Graph.i

@@ -28,6 +28,7 @@
 #include "Graph.hh"
 #include "FuncExpr.hh"
 #include "TimingRole.hh"
+#include "search/Levelize.hh"
 #include "Liberty.hh"
 #include "Network.hh"
 #include "Clock.hh"
@@ -118,6 +119,32 @@ remove_delay_slew_annotations()
   Sta::sta()->removeDelaySlewAnnotations();
 }
 
+void
+report_levelized_drvr_vertices(int max_count)
+{
+  Sta *sta = Sta::sta();
+  sta->ensureGraph();
+  const VertexSeq &drvrs = sta->levelizedDrvrVertices();
+  Report *report = sta->report();
+  const Network *network = sta->network();
+  report->report("driver vertex count {}", drvrs.size());
+  Level prev_level = -1;
+  int n = 0;
+  for (Vertex *vertex : drvrs) {
+    Level level = vertex->level();
+    if (level < prev_level)
+      report->report("level order violated {} {} < {}",
+                     network->pathName(vertex->pin()),
+                     level, prev_level);
+    if (n < max_count)
+      report->report("{} level={}",
+                     network->pathName(vertex->pin()),
+                     level);
+    prev_level = level;
+    n++;
+  }
+}
+
 %} // inline
 
 ////////////////////////////////////////////////////////////////

include/sta/Sta.hh

@@ -1325,6 +1325,7 @@ public:
   // Ensure that the timing graph has been built.
   Graph *ensureGraph();
   void ensureClkArrivals();
+  const VertexSeq& levelizedDrvrVertices();
 
   // Find all arc delays and vertex slews with delay calculator.
   virtual void findDelays();

search/Levelize.cc

@@ -53,7 +53,8 @@ Levelize::Levelize(StaState *sta) :
   level_space_(10),
   roots_(makeVertexSet(sta)),
   relevelize_from_(makeVertexSet(sta)),
-  observer_(nullptr)
+  observer_(nullptr),
+  drvr_vertices_level_valid_(false)
 {
 }
 
@@ -90,6 +91,8 @@ Levelize::clear()
   loops_.clear();
   loop_edges_.clear();
   max_level_ = 0;
+  drvr_vertices_level_valid_ = false;
+  levelized_drvr_vertices_.clear();
 }
 
 void
@@ -546,6 +549,7 @@ Levelize::setLevel(Vertex *vertex,
 void
 Levelize::invalid()
 {
+  drvr_vertices_level_valid_ = false;
   if (levelized_) {
     debugPrint(debug_, "levelize", 1, "levels invalid");
     levelized_ = false;
@@ -559,6 +563,8 @@ Levelize::deleteVertexBefore(Vertex *vertex)
   if (levelized_) {
     roots_.erase(vertex);
     relevelize_from_.erase(vertex);
+    drvr_vertices_level_valid_ = false;
+    levelized_drvr_vertices_.clear();
   }
 }
 
@@ -570,6 +576,7 @@ Levelize::relevelizeFrom(Vertex *vertex)
                vertex->to_string(this));
     relevelize_from_.insert(vertex);
     levels_valid_ = false;
+    drvr_vertices_level_valid_ = false;
   }
 }
 
@@ -584,6 +591,7 @@ Levelize::deleteEdgeBefore(Edge *edge)
     // fails because the DFS path will be missing.
     levelized_ = false;
     levels_valid_ = false;
+    drvr_vertices_level_valid_ = false;
   }
 }
 
@@ -710,6 +718,36 @@ Levelize::checkLevels()
   }
 }
 
+void
+Levelize::levelizeDrvrVertices()
+{
+  levelized_drvr_vertices_.clear();
+  // Rough estimate: ~half of vertices are drivers
+  levelized_drvr_vertices_.reserve(graph_->vertexCount() / 2);
+  VertexIterator vertex_iter(graph_);
+  while (vertex_iter.hasNext()) {
+    Vertex *vertex = vertex_iter.next();
+    if (vertex->isDriver(network_))
+      levelized_drvr_vertices_.emplace_back(vertex);
+  }
+  sort(levelized_drvr_vertices_,
+       [this](const Vertex *a, const Vertex *b) {
+         if (a->level() != b->level())
+           return a->level() < b->level();
+         return VertexNameLess(network_)(a, b);
+       });
+  drvr_vertices_level_valid_ = true;
+}
+
+const VertexSeq &
+Levelize::levelizedDrvrVertices()
+{
+  ensureLevelized();
+  if (!drvr_vertices_level_valid_)
+    levelizeDrvrVertices();
+  return levelized_drvr_vertices_;
+}
+
 ////////////////////////////////////////////////////////////////
 
 GraphLoop::GraphLoop(EdgeSeq *edges) :

search/Levelize.hh

@@ -74,7 +74,8 @@ public:
   void checkLevels();
   // Public for regression testing.
   void levelize();
-
+  const VertexSeq &levelizedDrvrVertices();
+  
 protected:
   void findRoots();
   VertexSeq sortedRootsWithFanout();
@@ -104,6 +105,7 @@ protected:
   void clearLoopEdges();
   void deleteLoops();
   void reportPath(EdgeSeq &path) const;
+  void levelizeDrvrVertices();
 
   bool levelized_;
   bool levels_valid_;
@@ -116,6 +118,8 @@ protected:
   EdgeSet disabled_loop_edges_;
   EdgeSet latch_d_to_q_edges_;
   LevelizeObserver *observer_;
+  VertexSeq levelized_drvr_vertices_;
+  bool drvr_vertices_level_valid_;
 };
 
 // Loops broken by levelization may not necessarily be combinational.

search/Sta.cc

@@ -2900,6 +2900,12 @@ Sta::ensureClkArrivals()
   search_->findClkArrivals();
 }
 
+const VertexSeq&
+Sta::levelizedDrvrVertices()
+{
+  return levelize_->levelizedDrvrVertices();
+}
+
 ////////////////////////////////////////////////////////////////
 
 VertexSet &