Merge branch 'parallaxsw:master' into main

doc/ChangeLog.txt

@@ -30,6 +30,9 @@ is now supported by the the read_saif command.
 
   read_saif [-scope scope] filename   
 
+The report_checks -group_count option has been renamed to -group_path_count.
+The report_checks -endpoing_count option has been renamed to -endpoint_path_count.
+
 Release 2.5.0 2024/01/17
 -------------------------
 

include/sta/PathGroup.hh

@@ -40,15 +40,15 @@ public:
   virtual ~PathGroup();
   // Path group that compares compare slacks.
   static PathGroup *makePathGroupArrival(const char *name,
-					 int group_count,
-					 int endpoint_count,
+					 int group_path_count,
+					 int endpoint_path_count,
 					 bool unique_pins,
 					 const MinMax *min_max,
 					 const StaState *sta);
   // Path group that compares arrival time, sorted by min_max.
   static PathGroup *makePathGroupSlack(const char *name,
-				       int group_count,
-				       int endpoint_count,
+				       int group_path_count,
+				       int endpoint_path_count,
 				       bool unique_pins,
 				       float min_slack,
 				       float max_slack,
@@ -57,20 +57,20 @@ public:
   const MinMax *minMax() const { return min_max_;}
   const PathEndSeq &pathEnds() const { return path_ends_; }
   void insert(PathEnd *path_end);
-  // Push group_count into path_ends.
+  // Push group_path_count into path_ends.
   void pushEnds(PathEndSeq &path_ends);
   // Predicates to determine if a PathEnd is worth saving.
   virtual bool savable(PathEnd *path_end);
-  int maxPaths() const { return group_count_; }
+  int maxPaths() const { return group_path_count_; }
   PathGroupIterator *iterator();
   // This does NOT delete the path ends.
   void clear();
-  static int group_count_max;
+  static int group_path_count_max;
 
 protected:
   PathGroup(const char *name,
-	    int group_count,
-	    int endpoint_count,
+	    int group_path_count,
+	    int endpoint_path_count,
 	    bool unique_pins,
 	    float min_slack,
 	    float max_slack,
@@ -82,8 +82,8 @@ protected:
   void sort();
 
   const char *name_;
-  int group_count_;
-  int endpoint_count_;
+  int group_path_count_;
+  int endpoint_path_count_;
   bool unique_pins_;
   float slack_min_;
   float slack_max_;
@@ -98,8 +98,8 @@ protected:
 class PathGroups : public StaState
 {
 public:
-  PathGroups(int group_count,
-	     int endpoint_count,
+  PathGroups(int group_path_count,
+	     int endpoint_path_count,
 	     bool unique_pins,
 	     float slack_min,
 	     float slack_max,
@@ -130,8 +130,8 @@ public:
 
 protected:
   void makeGroupPathEnds(ExceptionTo *to,
-			 int group_count,
-			 int endpoint_count,
+			 int group_path_count,
+			 int endpoint_path_count,
 			 bool unique_pins,
 			 const Corner *corner,
 			 const MinMaxAll *min_max);
@@ -144,17 +144,17 @@ protected:
 			 const MinMaxAll *min_max,
 			 PathEndVisitor *visitor);
   void enumPathEnds(PathGroup *group,
-		    int group_count,
-		    int endpoint_count,
+		    int group_path_count,
+		    int endpoint_path_count,
 		    bool unique_pins,
 		    bool cmp_slack);
 
   void pushGroupPathEnds(PathEndSeq &path_ends);
   void pushUnconstrainedPathEnds(PathEndSeq &path_ends,
 				 const MinMaxAll *min_max);
 
-  void makeGroups(int group_count,
-		  int endpoint_count,
+  void makeGroups(int group_path_count,
+		  int endpoint_path_count,
 		  bool unique_pins,
 		  float slack_min,
 		  float slack_max,
@@ -168,8 +168,8 @@ protected:
 		   PathGroupNameSet *group_names) const;
   GroupPath *groupPathTo(const PathEnd *path_end) const;
 
-  int group_count_;
-  int endpoint_count_;
+  int group_path_count_;
+  int endpoint_path_count_;
   bool unique_pins_;
   float slack_min_;
   float slack_max_;

include/sta/Search.hh

@@ -89,8 +89,8 @@ public:
                           bool unconstrained,
                           const Corner *corner,
                           const MinMaxAll *min_max,
-                          int group_count,
-                          int endpoint_count,
+                          int group_path_count,
+                          int endpoint_path_count,
                           bool unique_pins,
                           float slack_min,
                           float slack_max,
@@ -156,8 +156,8 @@ public:
 
   PathGroup *pathGroup(const PathEnd *path_end) const;
   void deletePathGroups();
-  void makePathGroups(int group_count,
-                      int endpoint_count,
+  void makePathGroups(int group_path_count,
+                      int endpoint_path_count,
                       bool unique_pins,
                       float min_slack,
                       float max_slack,

include/sta/Sta.hh

@@ -868,11 +868,11 @@ public:
                                   const MinMaxAll *min_max,
                                   // Number of path ends to report in
                                   // each group.
-                                  int group_count,
+                                  int group_path_count,
                                   // Number of paths to report for
                                   // each endpoint.
-                                  int endpoint_count,
-                                  // endpoint_count paths report unique pins
+                                  int endpoint_path_count,
+                                  // endpoint_path_count paths report unique pins
                                   // without rise/fall variations.
                                   bool unique_pins,
                                   // Min/max bounds for slack of

search/PathEnum.cc

@@ -96,15 +96,15 @@ deleteDiversionPathEnd(Diversion *div)
 
 ////////////////////////////////////////////////////////////////
 
-PathEnum::PathEnum(int group_count,
-		   int endpoint_count,
+PathEnum::PathEnum(int group_path_count,
+		   int endpoint_path_count,
 		   bool unique_pins,
 		   bool cmp_slack,
 		   const StaState *sta) :
   StaState(sta),
   cmp_slack_(cmp_slack),
-  group_count_(group_count),
-  endpoint_count_(endpoint_count),
+  group_path_count_(group_path_count),
+  endpoint_path_count_(endpoint_path_count),
   unique_pins_(unique_pins),
   div_queue_(DiversionGreater(sta)),
   div_count_(0),
@@ -181,7 +181,7 @@ PathEnum::findNext()
     }
 
     path_counts_[vertex]++;
-    if (path_counts_[vertex] <= endpoint_count_) {
+    if (path_counts_[vertex] <= endpoint_path_count_) {
       // Add diversions for all arcs converging on the path up to the
       // diversion.
       makeDiversions(path_end, div->divPath());
@@ -191,8 +191,10 @@ PathEnum::findNext()
       break;
     }
     else {
-      // We have endpoint_count paths for this endpoint, so we are done with it.
-      debugPrint(debug_, "path_enum", 1, "endpoint_count reached for %s",
+      // We have endpoint_path_count paths for this endpoint,
+      // so we are done with it.
+      debugPrint(debug_, "path_enum", 1,
+		 "endpoint_path_count reached for %s",
                  vertex->name(sdc_network_));
       deleteDiversionPathEnd(div);
     }
@@ -421,7 +423,7 @@ PathEnum::makeDiversion(PathEnd *div_end,
   div_queue_.push(div);
   div_count_++;
 
-  if (static_cast<int>(div_queue_.size()) > group_count_ * 2)
+  if (static_cast<int>(div_queue_.size()) > group_path_count_ * 2)
     // We have more potenial paths than we will need.
     pruneDiversionQueue();
 }
@@ -432,14 +434,14 @@ PathEnum::pruneDiversionQueue()
   debugPrint(debug_, "path_enum", 2, "prune queue");
   VertexPathCountMap path_counts;
   int end_count = 0;
-  // Collect endpoint_count diversions per vertex.
+  // Collect endpoint_path_count diversions per vertex.
   DiversionSeq divs;
   while (!div_queue_.empty()) {
     Diversion *div = div_queue_.top();
     Vertex *vertex = div->pathEnd()->vertex(this);
-    if (end_count < group_count_
+    if (end_count < group_path_count_
 	&& ((unique_pins_ && path_counts[vertex] == 0)
-	    || (!unique_pins_ && path_counts[vertex] < endpoint_count_))) {
+	    || (!unique_pins_ && path_counts[vertex] < endpoint_path_count_))) {
       divs.push_back(div);
       path_counts[vertex]++;
       end_count++;

search/PathEnum.hh

@@ -52,8 +52,8 @@ private:
 class PathEnum : public Iterator<PathEnd*>, StaState
 {
 public:
-  PathEnum(int group_count,
-	   int endpoint_count,
+  PathEnum(int group_path_count,
+	   int endpoint_path_count,
 	   bool unique_pins,
 	   bool cmp_slack,
 	   const StaState *sta);
@@ -88,12 +88,12 @@ private:
   void findNext();
 
   bool cmp_slack_;
-  int group_count_;
-  int endpoint_count_;
+  int group_path_count_;
+  int endpoint_path_count_;
   bool unique_pins_;
   DiversionQueue div_queue_;
   int div_count_;
-  // Number of paths returned for each endpoint (limited to endpoint_count).
+  // Number of paths returned for each endpoint (limit to endpoint_path_count).
   VertexPathCountMap path_counts_;
   bool inserts_pruned_;
   PathEnd *next_;