Merge branch 'parallaxsw:master' into main

Author: akashlevy

.cursor/rules/cpp-coding-standards.mdc

@@ -34,6 +34,13 @@ alwaysApply: true
 - Prefer `std::string` over `char*` for string members.
 - Prefer pass-by-value and move for sink parameters (parameters that get stored).
 
+## Control flow
+
+- Prefer positive `if` conditions that wrap the main logic instead of early
+  `continue` or `return` to skip work.
+- Example: use `if (!visited.contains(vertex)) { ... }` rather than
+  `if (visited.contains(vertex)) continue;`.
+
 ## File Extensions
 
 - C++ source: `.cc`

dcalc/GraphDelayCalc.cc

@@ -248,7 +248,7 @@ GraphDelayCalc::delayInvalid(Vertex *vertex)
 {
   debugPrint(debug_, "delay_calc", 2, "delay invalid {}",
              vertex->to_string(this));
-  if (graph_ && incremental_) {
+  if (incremental_) {
     invalid_delays_.insert(vertex);
     // Invalidate driver that triggers dcalc for multi-driver nets.
     MultiDrvrNet *multi_drvr = multiDrvrNet(vertex);
@@ -338,40 +338,38 @@ FindVertexDelays::visit(Vertex *vertex)
 void
 GraphDelayCalc::findDelays(Level level)
 {
-  if (arc_delay_calc_) {
-    Stats stats(debug_, report_);
-    int dcalc_count = 0;
-    debugPrint(debug_, "delay_calc", 1, "find delays to level {}", level);
-    if (!delays_seeded_) {
-      iter_->clear();
-      seedRootSlews();
-      delays_seeded_ = true;
-    }
-    else
-      iter_->ensureSize();
-    if (incremental_)
-      seedInvalidDelays();
+  Stats stats(debug_, report_);
+  int dcalc_count = 0;
+  debugPrint(debug_, "delay_calc", 1, "find delays to level {}", level);
+  if (!delays_seeded_) {
+    iter_->clear();
+    seedRootSlews();
+    delays_seeded_ = true;
+  }
+  else
+    iter_->ensureSize();
+  if (incremental_)
+    seedInvalidDelays();
 
-    if (!iter_->empty()) {
-      FindVertexDelays visitor(this);
-      dcalc_count += iter_->visitParallel(level, &visitor);
-    }
+  if (!iter_->empty()) {
+    FindVertexDelays visitor(this);
+    dcalc_count += iter_->visitParallel(level, &visitor);
+  }
 
-    // Timing checks require slews at both ends of the arc,
-    // so find their delays after all slews are known.
-    for (Edge *check_edge : invalid_check_edges_)
-      findCheckEdgeDelays(check_edge, arc_delay_calc_);
-    invalid_check_edges_.clear();
+  // Timing checks require slews at both ends of the arc,
+  // so find their delays after all slews are known.
+  for (Edge *check_edge : invalid_check_edges_)
+    findCheckEdgeDelays(check_edge, arc_delay_calc_);
+  invalid_check_edges_.clear();
 
-    for (Edge *latch_edge : invalid_latch_edges_)
-      findLatchEdgeDelays(latch_edge);
-    invalid_latch_edges_.clear();
+  for (Edge *latch_edge : invalid_latch_edges_)
+    findLatchEdgeDelays(latch_edge);
+  invalid_latch_edges_.clear();
 
-    delays_exist_ = true;
-    incremental_ = true;
-    debugPrint(debug_, "delay_calc", 1, "found {} delays", dcalc_count);
-    stats.report("Delay calc");
-  }
+  delays_exist_ = true;
+  incremental_ = true;
+  debugPrint(debug_, "delay_calc", 1, "found {} delays", dcalc_count);
+  stats.report("Delay calc");
 }
 
 void

doc/ApiChanges.txt

@@ -24,6 +24,11 @@
 
 This file summarizes STA API changes for each release.
 
+2026/06/22
+----------
+
+Liberty::hasSequentials has been renamed isSequential.
+
 Release 3.1.0 2026/03/25
 ------------------------
 

graph/Graph.cc

@@ -32,6 +32,7 @@
 #include "Mutex.hh"
 #include "Network.hh"
 #include "PortDirection.hh"
+#include "SearchPred.hh"
 #include "Stats.hh"
 #include "TimingArc.hh"
 #include "TimingRole.hh"
@@ -487,7 +488,7 @@ Graph::deleteVertex(Vertex *vertex)
   EdgeId edge_id, next_id;
   for (edge_id = vertex->in_edges_; edge_id; edge_id = next_id) {
     Edge *edge = Graph::edge(edge_id);
-    next_id = edge->vertex_in_link_;
+    next_id = edge->vertex_in_next_;
     deleteOutEdge(edge->from(this), edge);
     edge->clear();
     edges_->destroy(edge);
@@ -508,7 +509,7 @@ bool
 Graph::hasFaninOne(Vertex *vertex) const
 {
   return vertex->in_edges_
-    && edge(vertex->in_edges_)->vertex_in_link_ == 0;
+    && edge(vertex->in_edges_)->vertex_in_next_ == 0;
 }
 
 void
@@ -519,12 +520,12 @@ Graph::deleteInEdge(Vertex *vertex,
   EdgeId prev = 0;
   for (EdgeId i = vertex->in_edges_;
        i && i != edge_id;
-       i = Graph::edge(i)->vertex_in_link_)
+       i = Graph::edge(i)->vertex_in_next_)
     prev = i;
   if (prev)
-    Graph::edge(prev)->vertex_in_link_ = edge->vertex_in_link_;
+    Graph::edge(prev)->vertex_in_next_ = edge->vertex_in_next_;
   else
-    vertex->in_edges_ = edge->vertex_in_link_;
+    vertex->in_edges_ = edge->vertex_in_next_;
 }
 
 void
@@ -574,6 +575,76 @@ Graph::gateEdgeArc(const Pin *in_pin,
 
 ////////////////////////////////////////////////////////////////
 
+void
+Graph::visitFanouts(Vertex *vertex,
+                    SearchPred *pred,
+                    const VertexFn &fn)
+{
+  if (pred->searchFrom(vertex)) {
+    for (Edge *edge = this->edge(vertex->out_edges_);
+         edge;
+         edge = this->edge(edge->vertex_out_next_)) {
+      Vertex *to_vertex = this->vertex(edge->to_);
+      if (pred->searchThru(edge)
+          && pred->searchTo(to_vertex))
+        fn(to_vertex);
+    }
+  }
+}
+
+void
+Graph::visitFanoutEdges(Vertex *vertex,
+                        SearchPred *pred,
+                        const EdgeFn &fn)
+{
+  if (pred->searchFrom(vertex)) {
+    for (Edge *edge = this->edge(vertex->out_edges_);
+         edge;
+         edge = this->edge(edge->vertex_out_next_)) {
+      Vertex *to_vertex = this->vertex(edge->to_);
+      if (pred->searchThru(edge)
+          && pred->searchTo(to_vertex))
+        fn(edge, to_vertex);
+    }
+  }
+}
+
+void
+Graph::visitFanins(Vertex *vertex,
+                   SearchPred *pred,
+                   const VertexFn &fn)
+{
+  if (pred->searchFrom(vertex)) {
+    for (Edge *edge = this->edge(vertex->in_edges_);
+         edge;
+         edge = this->edge(edge->vertex_in_next_)) {
+      Vertex *from_vertex = this->vertex(edge->from_);
+      if (pred->searchThru(edge)
+          && pred->searchFrom(from_vertex))
+        fn(from_vertex);
+    }
+  }
+}
+
+void
+Graph::visitFaninEdges(Vertex *vertex,
+                       SearchPred *pred,
+                       const EdgeFn &fn)
+{
+  if (pred->searchFrom(vertex)) {
+    for (Edge *edge = this->edge(vertex->in_edges_);
+         edge;
+         edge = this->edge(edge->vertex_in_next_)) {
+      Vertex *from_vertex = this->vertex(edge->from_);
+      if (pred->searchThru(edge)
+          && pred->searchFrom(from_vertex))
+        fn(edge, from_vertex);
+    }
+  }
+}
+
+////////////////////////////////////////////////////////////////
+
 Slew
 Graph::slew(const Vertex *vertex,
             const RiseFall *rf,
@@ -650,7 +721,7 @@ Graph::makeEdge(Vertex *from,
   from->out_edges_ = edge_id;
 
   // Add in edge to to vertex.
-  edge->vertex_in_link_ = to->in_edges_;
+  edge->vertex_in_next_ = to->in_edges_;
   to->in_edges_ = edge_id;
 
   initArcDelays(edge);
@@ -1213,7 +1284,7 @@ Edge::init(VertexId from,
   from_ = from;
   to_ = to;
   arc_set_ = arc_set;
-  vertex_in_link_ = edge_id_null;
+  vertex_in_next_ = edge_id_null;
   vertex_out_next_ = edge_id_null;
   vertex_out_prev_ = edge_id_null;
   is_bidirect_inst_path_ = false;
@@ -1464,6 +1535,8 @@ VertexIterator::findNext()
     findNextPin();
 }
 
+////////////////////////////////////////////////////////////////
+
 VertexInEdgeIterator::VertexInEdgeIterator(Vertex *vertex,
                                            const Graph *graph) :
   next_(graph->edge(vertex->in_edges_)),
@@ -1483,7 +1556,7 @@ VertexInEdgeIterator::next()
 {
   Edge *next = next_;
   if (next_)
-    next_ = graph_->edge(next_->vertex_in_link_);
+    next_ = graph_->edge(next_->vertex_in_next_);
   return next;
 }
 

include/sta/Graph.hh

@@ -87,6 +87,19 @@ public:
   bool hasFaninOne(Vertex *vertex) const;
   VertexId vertexCount() { return vertices_->size(); }
 
+  void visitFanouts(Vertex *vertex,
+                    SearchPred *pred,
+                    const VertexFn &fn);
+  void visitFanins(Vertex *vertex,
+                   SearchPred *pred,
+                   const VertexFn &fn);
+  void visitFanoutEdges(Vertex *vertex,
+                        SearchPred *pred,
+                        const EdgeFn &fn);
+  void visitFaninEdges(Vertex *vertex,
+                       SearchPred *pred,
+                       const EdgeFn &fn);
+
   // Reported slew are the same as those in the liberty tables.
   //  reported_slews = measured_slews / slew_derate_from_library
   // Measured slews are between slew_lower_threshold and slew_upper_threshold.
@@ -394,7 +407,7 @@ protected:
   TimingArcSet *arc_set_;
   VertexId from_;
   VertexId to_;
-  EdgeId vertex_in_link_;               // Vertex in edges list.
+  EdgeId vertex_in_next_;               // Vertex in edges list.
   EdgeId vertex_out_next_;              // Vertex out edges doubly linked list.
   EdgeId vertex_out_prev_;
   float *arc_delays_;

include/sta/GraphClass.hh

@@ -65,6 +65,8 @@ using Level = int;
 using DcalcAPIndex = int;
 using TagGroupIndex = int;
 using SlewSeq = std::vector<Slew>;
+using VertexFn = std::function<void(Vertex*)>;
+using EdgeFn = std::function<void(Edge *, Vertex*)>;
 
 static constexpr int level_max = std::numeric_limits<Level>::max();
 

include/sta/Liberty.hh

@@ -543,7 +543,9 @@ public:
   bool leakagePowerExists() const { return leakage_power_exists_; }
 
   // Register, Latch or Statetable.
-  bool hasSequentials() const;
+  bool isSequential() const;
+  // deprecated 2026-06-22 (use isSequential)
+  bool hasSequentials() const __attribute__ ((deprecated));
   const SequentialSeq &sequentials() const { return sequentials_; }
   // Find the sequential with the output connected to an (internal) port.
   Sequential *outputPortSequential(LibertyPort *port);

include/sta/Search.hh

@@ -290,8 +290,8 @@ public:
                                Vertex *vertex,
                                const Mode *mode,
                                TagGroupBldr *tag_bldr);
-  void enqueueLatchDataOutputs(Vertex *vertex);
-  void enqueueLatchOutput(Vertex *vertex);
+  void postponeLatchDataOutputs(Vertex *vertex);
+  void postponeArrivals(Vertex *vertex);
   void enqueuePendingClkFanouts();
   void postponeClkFanouts(Vertex *vertex);
   void seedRequired(Vertex *vertex);
@@ -596,7 +596,7 @@ protected:
 
   // Search predicates.
   SearchPred *search_thru_;
-  SearchAdj *search_adj_;
+  SearchPred *search_adj_;
   EvalPred *eval_pred_;
 
   // Clock arrivals are known.
@@ -657,11 +657,11 @@ protected:
   std::mutex tag_group_lock_;
 
   // Latches data outputs to queue on the next search pass.
-  VertexSet pending_latch_outputs_;
-  std::mutex pending_latch_outputs_lock_;
+  VertexSet postponed_arrivals_;
+  std::mutex postponed_arrivals_lock_;
   // Clock network endpoints where arrival search was suppended by findClkArrivals().
-  VertexSet pending_clk_endpoints_;
-  std::mutex pending_clk_endpoints_lock_;
+  VertexSet postponed_clk_endpoints_;
+  std::mutex postponed_clk_endpoints_lock_;
 
   VertexSet endpoints_;
   bool endpoints_initialized_{false};
@@ -812,6 +812,8 @@ protected:
   void pruneCrprArrivals();
   void constrainedRequiredsInvalid(Vertex *vertex,
                                    bool is_clk);
+  bool hasPendingLoopPaths(Edge *edge) const;
+
   bool always_to_endpoints_;
   bool always_save_prev_paths_;
   bool clks_only_;

include/sta/SearchPred.hh

@@ -51,19 +51,19 @@ public:
   // Search is allowed from from_vertex.
   virtual bool searchFrom(const Vertex *from_vertex,
                           const Mode *mode) const = 0;
-  bool searchFrom(const Vertex *from_vertex) const;
+  virtual bool searchFrom(const Vertex *from_vertex) const;
   // Search is allowed through edge.
   // from/to pins are NOT checked.
   // inst can be either the from_pin or to_pin instance because it
   // is only referenced when they are the same (non-wire edge).
   virtual bool searchThru(Edge *edge,
                           const Mode *mode) const = 0;
-  bool searchThru(Edge *edge) const;
+  virtual bool searchThru(Edge *edge) const;
   // Search is allowed to to_pin.
   virtual bool searchTo(const Vertex *to_vertex,
                         const Mode *mode) const = 0;
-  bool searchTo(const Vertex *to_vertex) const;
-  void copyState(const StaState *sta);
+  virtual bool searchTo(const Vertex *to_vertex) const;
+  virtual void copyState(const StaState *sta);
 
 protected:
   const StaState *sta_;

include/sta/Sta.hh

@@ -1575,7 +1575,6 @@ protected:
                                   bool infer_latches);
   void delayCalcPreamble();
   void delaysInvalidFrom(const Port *port);
-  void delaysInvalidFromFanin(const Port *port);
   void deleteEdge(Edge *edge);
   void netParasiticCaps(Net *net,
                         const RiseFall *rf,