Add timing paths export to Liberty

include/sta/Liberty.hh

@@ -36,6 +36,7 @@
 #include "Transition.hh"
 #include "Delay.hh"
 #include "LibertyClass.hh"
+#include "TimingArc.hh"
 
 namespace sta {
 
@@ -561,6 +562,13 @@ public:
   const char *userFunctionClass() const;
   void setUserFunctionClass(const char *user_function_class);
 
+  void addInternalTimingPath(InputRegisterTimingPath timing_path,
+                             const MinMax *min_max,
+                             const RiseFall *rise_fall);
+  const std::vector<InputRegisterTimingPath> &getInternalTimingPaths(const MinMax *min_max,
+                                                                     const RiseFall *rise_fall) const;
+  bool hasInternalTimingPaths() const;
+
 protected:
   void addPort(ConcretePort *port);
   void setHasInternalPorts(bool has_internal);
@@ -652,6 +660,8 @@ protected:
   std::mutex waveform_lock_;
   std::string footprint_;
   std::string user_function_class_;
+  float worst_slack_{std::numeric_limits<float>::max()};
+  std::array<std::array<std::vector<InputRegisterTimingPath>, 2>, 2> internal_timing_paths_;
 
 private:
   friend class LibertyLibrary;

include/sta/LibertyWriter.hh

@@ -33,6 +33,7 @@ class StaState;
 void
 writeLiberty(LibertyLibrary *lib,
              const char *filename,
-             StaState *sta);
+             StaState *sta,
+             bool write_timing_paths);
 
 } // namespace

include/sta/PathGroup.hh

@@ -134,8 +134,15 @@ public:
   PathGroup *findPathGroup(const Clock *clock,
 			   const MinMax *min_max) const;
   PathGroup *pathGroup(const PathEnd *path_end) const;
+  PathGroup *pathDelayGroup(const MinMax *min_max) const { return path_delay_[min_max->index()]; }
+  PathGroup *gatedClkGroup(const MinMax *min_max) const { return gated_clk_[min_max->index()]; }
+  PathGroup *asyncGroup(const MinMax *min_max) const { return async_[min_max->index()]; }
+  PathGroup *unconstrainedGroup(const MinMax *min_max) const { return unconstrained_[min_max->index()]; }
   static bool isGroupPathName(const char *group_name);
+  static const char *pathDelayPathGroupName() { return path_delay_group_name_; }
+  static const char *gatedClkPathGroupName() { return gated_clk_group_name_; }
   static const char *asyncPathGroupName() { return async_group_name_; }
+  static const char *unconstrainedPathGroupName() { return unconstrained_group_name_; }
 
 protected:
   void makeGroupPathEnds(ExceptionTo *to,

include/sta/Search.hh

@@ -208,6 +208,7 @@ public:
   void visitStartpoints(VertexVisitor *visitor);
   void visitEndpoints(VertexVisitor *visitor);
   bool havePathGroups() const;
+  const PathGroups *pathGroups() const { return path_groups_; }
   PathGroup *findPathGroup(const char *name,
 			   const MinMax *min_max) const;
   PathGroup *findPathGroup(const Clock *clk,
@@ -411,6 +412,19 @@ public:
   void checkPrevPaths() const;
   void deletePaths(Vertex *vertex);
 
+  InternalPathSeq findInternalTimingPaths(const MinMaxAll *delay_min_max,
+                                          const RiseFallBoth *transition_rise_fall,
+                                          float slack_min,
+                                          float slack_max,
+                                          bool sort_by_slack,
+                                          PathGroupNameSet *groups,
+                                          unsigned int path_count);
+
+  PathsStitch mergePaths(const PathEndSeq *path_ends,
+                         const InternalPathSeq *timing_paths,
+                         bool sort_by_slack,
+                         unsigned int path_count);
+
 protected:
   void init(StaState *sta);
   void initVars();
@@ -582,6 +596,13 @@ protected:
   void clockDomains(const Vertex *vertex,
                     // Return value.
                     ClockSet &clks) const;
+  bool isSlackInsideSearchingBounds(float slack, float min_slack, float max_slack) const;
+  bool isMatchingSearchedPathGroups(const char *path_group, PathGroupNameSet *group_names) const;
+  PathGroup *findPathGroupForInternalPath(const InputRegisterTimingPath *timing_path) const;
+  void mergePathsBySlack(
+    PathEndSeq &input_path_ends, InternalPathSeq &input_internal_paths,
+    PathEndSeq &filtered_path_ends, InternalPathSeq &filtered_internal_paths,
+    unsigned int group_path_count) const;
 
   ////////////////////////////////////////////////////////////////
 

include/sta/SearchClass.hh

@@ -35,6 +35,7 @@
 #include "Delay.hh"
 #include "NetworkClass.hh"
 #include "GraphClass.hh"
+#include "TimingArc.hh"
 
 namespace sta {
 
@@ -113,6 +114,8 @@ typedef Vector<MinPeriodCheck*> MinPeriodCheckSeq;
 typedef Vector<MaxSkewCheck*> MaxSkewCheckSeq;
 typedef StringSet PathGroupNameSet;
 typedef Vector<PathEnd*> PathEndSeq;
+typedef Vector<const InputRegisterTimingPath*> InternalPathSeq;
+typedef std::set<const InputRegisterTimingPath*> InternalPathSet;
 typedef Vector<Arrival> ArrivalSeq;
 typedef Map<Vertex*, size_t> VertexPathCountMap;
 typedef Map<Tag*, size_t, TagMatchLess> PathIndexMap;
@@ -136,6 +139,48 @@ enum class ReportDeduplicationMode { none,
 			      keep_different
 };
 
+class PathsStitch
+{
+public:
+  PathsStitch() = default;
+
+  PathsStitch(
+      PathEndSeq path_ends,
+      InternalPathSeq internal_timing_paths,
+      bool sorted_by_slack)
+    : path_ends_{std::move(path_ends)},
+    internal_timing_paths_{std::move(internal_timing_paths)},
+    sorted_by_slack_{sorted_by_slack},
+    num_of_paths_{static_cast<unsigned int>(path_ends_.size() + internal_timing_paths_.size())} {}
+
+  PathsStitch(
+      PathEndSeq path_ends,
+      bool sorted_by_slack)
+    : path_ends_{std::move(path_ends)},
+    sorted_by_slack_{sorted_by_slack},
+    num_of_paths_{static_cast<unsigned int>(path_ends_.size())} {}
+
+  PathsStitch(
+      InternalPathSeq internal_timing_paths,
+      bool sorted_by_slack)
+    : internal_timing_paths_{std::move(internal_timing_paths)},
+    sorted_by_slack_{sorted_by_slack},
+    num_of_paths_{static_cast<unsigned int>(internal_timing_paths_.size())} {}
+
+  bool hasPathEnds() const { return !path_ends_.empty(); }
+  const PathEndSeq &pathEnds() const { return path_ends_; }
+  bool hasInternalPaths() const { return !internal_timing_paths_.empty(); }
+  const InternalPathSeq &internalPaths() const { return internal_timing_paths_; }
+  bool sortedBySlack() const { return sorted_by_slack_; }
+  unsigned int size() const { return num_of_paths_; }
+
+private:
+  PathEndSeq path_ends_{};
+  InternalPathSeq internal_timing_paths_{};
+  bool sorted_by_slack_{false};
+  unsigned int num_of_paths_{0};
+};
+
 static const TagIndex tag_index_bit_count = 28;
 static const TagIndex tag_index_max = (1 << tag_index_bit_count) - 1;
 static const TagIndex tag_index_null = tag_index_max;

include/sta/Sta.hh

@@ -836,6 +836,17 @@ public:
                                   bool removal,
                                   bool clk_gating_setup,
                                   bool clk_gating_hold);
+  InternalPathSeq findInternalTimingPaths(const MinMaxAll *delay_min_max,
+                                          const RiseFallBoth *transition_rise_fall,
+                                          float slack_min,
+                                          float slack_max,
+                                          bool sort_by_slack,
+                                          PathGroupNameSet *groups,
+                                          int path_count);
+  PathsStitch mergePaths(const PathEndSeq *path_ends,
+                         const InternalPathSeq *timing_paths,
+                         bool sort_by_slack,
+                         unsigned int path_count);
   void setReportPathFormat(ReportPathFormat format);
   void setReportPathFieldOrder(StringSeq *field_names);
   void setReportPathFields(bool report_input_pin,
@@ -862,8 +873,11 @@ public:
 		     PathEnd *prev_end);
   void reportPathEnd(PathEnd *end);
   void reportPathEnds(PathEndSeq *ends);
+  void reportPaths(const PathsStitch *paths_stitch);
   ReportPath *reportPath() { return report_path_; }
   void reportPath(const Path *path);
+  void reportPath(const InputRegisterTimingPath *internal_path);
+  void reportPaths(const InternalPathSeq *internal_paths);
 
   // Report clk skews for clks.
   void reportClkSkew(ConstClockSeq &clks,
@@ -1249,7 +1263,9 @@ public:
                         const char *cell_name,
                         const char *filename,
                         const Corner *corner,
-			const bool scalar);
+			const bool scalar,
+			const bool paths,
+                        const int internal_path_count);
 
   // Find equivalent cells in equiv_libs.
   // Optionally add mappings for cells in map_libs.

include/sta/TimingArc.hh

@@ -25,11 +25,14 @@
 #pragma once
 
 #include <memory>
+#include <unordered_map>
+#include <limits>
 
 #include "Vector.hh"
 #include "Transition.hh"
 #include "Delay.hh"
 #include "LibertyClass.hh"
+#include "TimingRole.hh"
 
 namespace sta {
 
@@ -93,6 +96,90 @@ timingTypeScaleFactorType(TimingType type);
 
 ////////////////////////////////////////////////////////////////
 
+struct TimingPathVertex
+{
+  std::string instance;
+  std::string cell;
+  std::string pin;
+  std::string net;
+  std::string transition;
+  float arrival;
+  float slew;
+  float capacitance;
+  bool is_driver;
+};
+
+struct TimingPath
+{
+  std::string name{};
+  std::vector<TimingPathVertex> vertices{};
+  float time{0.0f};
+  const RiseFall* rise_fall;
+
+  struct Names
+  {
+    static constexpr std::array<const char*, 2> DATA_ARRIVAL{"rise_data_arrival", "fall_data_arrival"};
+    static constexpr std::array<const char*, 2> DATA_REQUIRED{"rise_data_required", "fall_data_required"};
+    static constexpr std::array<const char*, 2> CLOCKED_OUTPUT{"rise_clocked_output", "fall_clocked_output"};
+    static constexpr std::array<const char*, 2> COMBINATIONAL{"rise_combinational", "fall_combinational"};
+    static constexpr std::array<const char*, 2> SOURCE_CLOCK{"rise_source_clock", "fall_source_clock"};
+  };
+
+  inline static const std::unordered_map<const TimingRole*, std::array<const char*, 2>> ROLE_PATH_MAPPINGS =
+  {
+    {TimingRole::regClkToQ(), Names::CLOCKED_OUTPUT},
+    {TimingRole::combinational(), Names::COMBINATIONAL},
+    {TimingRole::setup(), Names::DATA_ARRIVAL},
+    {TimingRole::hold(), Names::DATA_ARRIVAL}
+  };
+
+  bool isDataArrivalPath() const;
+  bool isDataRequiredPath() const;
+  bool isSourceClockPath() const;
+};
+
+struct InputRegisterTimingPath
+{
+  float slack{std::numeric_limits<float>::max()};
+  float crpr{std::numeric_limits<float>::max()};
+  float clk_arrival{std::numeric_limits<float>::max()};
+  float library_setup_time{std::numeric_limits<float>::max()};
+  float path_delay{std::numeric_limits<float>::max()};
+  bool has_path_delay{false};
+  bool is_source_clock_propagated{false};
+  bool is_target_clock_propagated{false};
+  std::string cell_name{};
+  std::string path_group_name{};
+  std::string path_type{};
+  std::string type{};
+  const RiseFall *source_clock_transition{nullptr};
+  std::string source_clock_name{};
+  float source_clk_time{std::numeric_limits<float>::max()};
+  float source_clk_arrival{std::numeric_limits<float>::max()};
+  const RiseFall *target_clock_transition{nullptr};
+  std::string target_clock_name{};
+  float target_clk_delay{std::numeric_limits<float>::max()};
+  float target_clk_time{std::numeric_limits<float>::max()};
+  float target_clk_offset{std::numeric_limits<float>::max()};
+  float target_clk_mcp_adjustment{std::numeric_limits<float>::max()};
+  float target_clk_insertion_delay{std::numeric_limits<float>::max()};
+  float target_clk_insertion_offset{std::numeric_limits<float>::max()};
+  float target_clk_non_inter_uncertainty{std::numeric_limits<float>::max()};
+  float target_clk_uncertainty{std::numeric_limits<float>::max()};
+  TimingPath source_clock_path{};
+  TimingPath data_arrival_path{};
+  TimingPath data_required_path{};
+};
+
+struct CombinationalTimingPath
+{
+  float slack{std::numeric_limits<float>::max()};
+  TimingPath source_clock_path{};
+  TimingPath combinational_delay_path{};
+};
+
+////////////////////////////////////////////////////////////////
+
 class TimingArcAttrs
 {
 public:
@@ -120,6 +207,11 @@ public:
 		TimingModel *model);
   float ocvArcDepth() const { return ocv_arc_depth_; }
   void setOcvArcDepth(float depth);
+  void setSlack(float slack);
+  void mergeSlack(float slack);
+  void addTimingPath(TimingPath timing_path);
+  float slack() const { return slack_; }
+  const std::unordered_map<std::string, TimingPath>& timingPaths() const { return timing_paths_; }
 
 protected:
   TimingType timing_type_;
@@ -132,6 +224,8 @@ protected:
   const char *mode_value_;
   float ocv_arc_depth_;
   TimingModel *models_[RiseFall::index_count];
+  float slack_{std::numeric_limits<float>::max()};
+  std::unordered_map<std::string, TimingPath> timing_paths_;
 };
 
 // A timing arc set is a group of related timing arcs between from/to
@@ -184,6 +278,10 @@ public:
   const char *sdfCondEnd() const { return attrs_->sdfCondEnd(); }
   const char *modeName() const { return attrs_->modeName(); }
   const char *modeValue() const { return attrs_->modeValue(); }
+  float slack() const { return attrs_->slack(); }
+  bool hasTimingPaths() const { return !attrs_->timingPaths().empty(); }
+  const std::unordered_map<std::string, TimingPath>& timingPaths() const { return attrs_->timingPaths(); }
+
   // Timing arc set index in cell.
   TimingArcIndex index() const { return index_; }
   bool isDisabledConstraint() const { return is_disabled_constraint_; }
@@ -281,3 +379,25 @@ private:
 };
 
 } // namespace
+
+namespace std {
+
+  template<>
+  struct less<sta::InputRegisterTimingPath>
+  {
+    bool operator()(const sta::InputRegisterTimingPath &first, const sta::InputRegisterTimingPath &second) const
+    {
+      return first.slack < second.slack;
+    }
+  };
+
+  template<>
+  struct less<const sta::InputRegisterTimingPath*>
+  {
+    bool operator()(const sta::InputRegisterTimingPath *first, const sta::InputRegisterTimingPath *second) const
+    {
+      return first->slack < second->slack;
+    }
+  };
+
+}