Merge pull request The-OpenROAD-Project#9498 from The-OpenROAD-Project-staging/sta-mcmm

Update to build with multi-mode STA

Author: maliberty

include/ord/Timing.h

@@ -22,7 +22,7 @@ class dbNet;
 
 namespace sta {
 class dbSta;
-class Corner;
+class Scene;
 class LibertyCell;
 class Network;
 class Sta;
@@ -67,17 +67,17 @@ class Timing
   bool isEndpoint(odb::dbITerm* db_pin);
   bool isEndpoint(odb::dbBTerm* db_pin);
 
-  float getNetCap(odb::dbNet* net, sta::Corner* corner, MinMax minmax);
-  float getPortCap(odb::dbITerm* pin, sta::Corner* corner, MinMax minmax);
+  float getNetCap(odb::dbNet* net, sta::Scene* corner, MinMax minmax);
+  float getPortCap(odb::dbITerm* pin, sta::Scene* corner, MinMax minmax);
   float getMaxCapLimit(odb::dbMTerm* pin);
   float getMaxSlewLimit(odb::dbMTerm* pin);
-  float staticPower(odb::dbInst* inst, sta::Corner* corner);
-  float dynamicPower(odb::dbInst* inst, sta::Corner* corner);
+  float staticPower(odb::dbInst* inst, sta::Scene* corner);
+  float dynamicPower(odb::dbInst* inst, sta::Scene* corner);
 
   std::vector<odb::dbMTerm*> getTimingFanoutFrom(odb::dbMTerm* input);
-  std::vector<sta::Corner*> getCorners();
-  sta::Corner* cmdCorner();
-  sta::Corner* findCorner(const char* name);
+  std::vector<sta::Scene*> getCorners();
+  sta::Scene* cmdCorner();
+  sta::Scene* findCorner(const char* name);
 
   void makeEquivCells();
   std::vector<odb::dbMaster*> equivCells(odb::dbMaster* master);

src/Metrics.tcl

@@ -161,7 +161,7 @@ proc report_erc_metrics { } {
 define_cmd_args "report_power_metric" {[-corner corner_name]}
 proc report_power_metric { args } {
   parse_key_args "report_power_metric" args keys {-corner} flags {}
-  set corner [sta::parse_corner keys]
+  set corner [sta::parse_scene keys]
   set power_result [design_power $corner]
   set totals [lrange $power_result 0 3]
   lassign $totals design_internal design_switching design_leakage design_total

src/OpenRoad-py.i

@@ -47,7 +47,7 @@ get_db_block();
 
 %}
 
-%template(Corners) std::vector<sta::Corner*>;
+%template(Corners) std::vector<sta::Scene*>;
 %template(MTerms) std::vector<odb::dbMTerm*>;
 %template(Masters) std::vector<odb::dbMaster*>;
 

src/OpenRoad.cc

@@ -661,7 +661,10 @@ void OpenRoad::setThreadCount(int threads, bool print_info)
   }
 
   // place limits on tools with threads
-  sta_->setThreadCount(threads_);
+  // sta_->setThreadCount(threads_);
+
+  // Temporary until some issues can be resolved related to multi-mode.
+  sta_->setThreadCount(1);
 }
 
 void OpenRoad::setThreadCount(const char* threads, bool print_info)

src/Tech.cc

@@ -9,9 +9,9 @@
 #include "db_sta/dbSta.hh"
 #include "odb/db.h"
 #include "ord/OpenRoad.hh"
-#include "sta/Corner.hh"
 #include "sta/Liberty.hh"
 #include "sta/MinMax.hh"
+#include "sta/Scene.hh"
 #include "sta/Units.hh"
 #include "tcl.h"
 
@@ -73,7 +73,7 @@ void Tech::readLiberty(const std::string& file_name)
 {
   // TODO: take corner & min/max args
   getSta()->readLiberty(file_name.c_str(),
-                        getSta()->cmdCorner(),
+                        getSta()->cmdScene(),
                         sta::MinMaxAll::all(),
                         true /* infer_latches */);
 }

src/Timing.cc

@@ -18,13 +18,14 @@
 #include "ord/Tech.h"
 #include "rsz/Resizer.hh"
 #include "sta/Clock.hh"
-#include "sta/Corner.hh"
 #include "sta/DelayFloat.hh"
 #include "sta/Graph.hh"
 #include "sta/Liberty.hh"
 #include "sta/LibertyClass.hh"
 #include "sta/MinMax.hh"
+#include "sta/Mode.hh"
 #include "sta/PowerClass.hh"
+#include "sta/Scene.hh"
 #include "sta/SdcClass.hh"
 #include "sta/Search.hh"
 #include "sta/TimingArc.hh"
@@ -79,15 +80,8 @@ bool Timing::isEndpoint(sta::Pin* sta_pin)
 float Timing::slewAllCorners(sta::Vertex* vertex, const sta::MinMax* minmax)
 {
   auto sta = getSta();
-  bool max = (minmax == sta::MinMax::max());
-  float slew = (max) ? -sta::INF : sta::INF;
-  float slew_corner;
-  for (auto corner : getCorners()) {
-    slew_corner = sta::delayAsFloat(
-        sta->vertexSlew(vertex, sta::RiseFall::rise(), corner, minmax));
-    slew = (max) ? std::max(slew, slew_corner) : std::min(slew, slew_corner);
-  }
-  return slew;
+  return sta::delayAsFloat(
+      sta->slew(vertex, sta::RiseFallBoth::riseFall(), sta->scenes(), minmax));
 }
 
 float Timing::getPinSlew(odb::dbITerm* db_pin, MinMax minmax)
@@ -145,24 +139,6 @@ std::array<sta::Vertex*, 2> Timing::vertices(const sta::Pin* pin)
   return vertices;
 }
 
-std::vector<float> Timing::arrivalsClk(const sta::RiseFall* rf,
-                                       sta::Clock* clk,
-                                       const sta::RiseFall* clk_rf,
-                                       sta::Vertex* vertex)
-{
-  auto sta = getSta();
-  std::vector<float> arrivals;
-  const sta::ClockEdge* clk_edge = nullptr;
-  if (clk) {
-    clk_edge = clk->edge(clk_rf);
-  }
-  for (auto path_ap : sta->corners()->pathAnalysisPts()) {
-    arrivals.push_back(sta::delayAsFloat(
-        sta->vertexArrival(vertex, rf, clk_edge, path_ap, nullptr)));
-  }
-  return arrivals;
-}
-
 bool Timing::isTimeInf(float time)
 {
   return (time > 1e+10 || time < -1e+10);
@@ -171,16 +147,15 @@ bool Timing::isTimeInf(float time)
 float Timing::getPinArrivalTime(sta::Clock* clk,
                                 const sta::RiseFall* clk_rf,
                                 sta::Vertex* vertex,
-                                const sta::RiseFall* arrive_hold)
+                                const sta::RiseFall* rf)
 {
-  std::vector<float> times = arrivalsClk(arrive_hold, clk, clk_rf, vertex);
-  float delay = -sta::INF;
-  for (float delay_time : times) {
-    if (!isTimeInf(delay_time)) {
-      delay = std::max(delay, delay_time);
-    }
+  sta::dbSta* sta = getSta();
+  if (clk) {
+    return sta::delayAsFloat(sta->arrival(
+        vertex, rf, clk->edge(clk_rf), sta->scenes(), sta::MinMax::max()));
   }
-  return delay;
+  return sta::delayAsFloat(sta->arrival(
+      vertex, rf->asRiseFallBoth(), sta->scenes(), sta::MinMax::max()));
 }
 
 sta::ClockSeq Timing::findClocksMatching(const char* pattern,
@@ -190,7 +165,7 @@ sta::ClockSeq Timing::findClocksMatching(const char* pattern,
   auto sta = getSta();
   cmdLinkedNetwork();
   sta::PatternMatch matcher(pattern, regexp, nocase, sta->tclInterp());
-  return sta->sdc()->findClocksMatching(&matcher);
+  return sta->cmdMode()->sdc()->findClocksMatching(&matcher);
 }
 
 float Timing::getPinArrival(odb::dbITerm* db_pin, RiseFall rf, MinMax minmax)
@@ -212,7 +187,8 @@ float Timing::getPinArrival(sta::Pin* sta_pin, RiseFall rf, MinMax minmax)
   auto vertex_array = vertices(sta_pin);
   float delay = (minmax == Max) ? -sta::INF : sta::INF;
   float d1, d2;
-  sta::Clock* default_arrival_clock = getSta()->sdc()->defaultArrivalClock();
+  sta::Clock* default_arrival_clock
+      = getSta()->cmdMode()->sdc()->defaultArrivalClock();
   for (auto vertex : vertex_array) {
     if (vertex == nullptr) {
       continue;
@@ -234,21 +210,21 @@ float Timing::getPinArrival(sta::Pin* sta_pin, RiseFall rf, MinMax minmax)
   return delay;
 }
 
-std::vector<sta::Corner*> Timing::getCorners()
+std::vector<sta::Scene*> Timing::getCorners()
 {
-  sta::Corners* corners = getSta()->corners();
-  return {corners->begin(), corners->end()};
+  auto& corners = getSta()->scenes();
+  return {corners.begin(), corners.end()};
 }
 
-sta::Corner* Timing::cmdCorner()
+sta::Scene* Timing::cmdCorner()
 {
-  return getSta()->cmdCorner();
+  return getSta()->cmdScene();
 }
 
-sta::Corner* Timing::findCorner(const char* name)
+sta::Scene* Timing::findCorner(const char* name)
 {
   for (auto* corner : getCorners()) {
-    if (strcmp(corner->name(), name) == 0) {
+    if (strcmp(corner->name().c_str(), name) == 0) {
       return corner;
     }
   }
@@ -274,7 +250,8 @@ float Timing::getPinSlack(sta::Pin* sta_pin, RiseFall rf, MinMax minmax)
 {
   sta::dbSta* sta = getSta();
   auto sta_rf = (rf == Rise) ? sta::RiseFall::rise() : sta::RiseFall::fall();
-  return sta->pinSlack(sta_pin, sta_rf, getMinMax(minmax));
+  return sta->slack(
+      sta_pin, sta_rf->asRiseFallBoth(), sta->scenes(), getMinMax(minmax));
 }
 
 // I'd like to return a std::set but swig gave me way too much grief
@@ -319,7 +296,7 @@ const sta::MinMax* Timing::getMinMax(MinMax type)
   return type == Max ? sta::MinMax::max() : sta::MinMax::min();
 }
 
-float Timing::getNetCap(odb::dbNet* net, sta::Corner* corner, MinMax minmax)
+float Timing::getNetCap(odb::dbNet* net, sta::Scene* corner, MinMax minmax)
 {
   sta::dbSta* sta = getSta();
   sta::Net* sta_net = sta->getDbNetwork()->dbToSta(net);
@@ -330,7 +307,7 @@ float Timing::getNetCap(odb::dbNet* net, sta::Corner* corner, MinMax minmax)
   return pin_cap + wire_cap;
 }
 
-float Timing::getPortCap(odb::dbITerm* pin, sta::Corner* corner, MinMax minmax)
+float Timing::getPortCap(odb::dbITerm* pin, sta::Scene* corner, MinMax minmax)
 {
   sta::dbSta* sta = getSta();
   sta::dbNetwork* network = sta->getDbNetwork();
@@ -375,7 +352,7 @@ float Timing::getMaxSlewLimit(odb::dbMTerm* pin)
   return max_slew;
 }
 
-float Timing::staticPower(odb::dbInst* inst, sta::Corner* corner)
+float Timing::staticPower(odb::dbInst* inst, sta::Scene* corner)
 {
   sta::dbSta* sta = getSta();
   sta::dbNetwork* network = sta->getDbNetwork();
@@ -388,7 +365,7 @@ float Timing::staticPower(odb::dbInst* inst, sta::Corner* corner)
   return power.leakage();
 }
 
-float Timing::dynamicPower(odb::dbInst* inst, sta::Corner* corner)
+float Timing::dynamicPower(odb::dbInst* inst, sta::Scene* corner)
 {
   sta::dbSta* sta = getSta();
   sta::dbNetwork* network = sta->getDbNetwork();