luke
/
OpenSTA
mirror of https://github.com/The-OpenROAD-Project/OpenSTA.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

report_clock_latency -include_internal_latency 

Signed-off-by: James Cherry <cherry@parallaxsw.com>
This commit is contained in:
James Cherry 2024-05-11 18:12:55 -07:00
parent 986260595f
commit 05e38d730a
11 changed files with 60 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
doc/ChangeLog.txt
View File

@ -16,6 +16,14 @@ replaced with the -reduce flag. With the -reduce flag, the current
delay calculator reduces the parastic network to the appropriate type
and deletes the parasitic network.
The report_clock_skew and report_clock_latency commands now supports
the -include_internal_latency flag to control inclusion of macro
internal clock delays from the cell liberty min/max_clock_tree_path
timing groups.
report_clock_skew -include_internal_latency
report_clock_latency -include_internal_latency
Release 2.4.0 2023/01/19
-------------------------

BIN
doc/OpenSTA.odt
View File

Binary file not shown.

BIN
doc/OpenSTA.pdf
View File

Binary file not shown.

4
include/sta/Sta.hh
View File

@ -921,9 +921,11 @@ public:
void reportClkLatency(ConstClockSeq clks,
const Corner *corner,
bool include_internal_latency,
int digits);
// Find min/max/rise/fall delays for clk.
ClkDelays findClkDelays(const Clock *clk);
ClkDelays findClkDelays(const Clock *clk,
bool include_internal_latency);
// Update arrival times for all pins.
// If necessary updateTiming propagates arrivals around latch

5
search/ClkDelays.hh
View File

@ -33,7 +33,7 @@ public:
// Return values.
Delay &insertion,
Delay &delay,
float &lib_clk_delay,
float &internal_latency,
Delay &latency,
PathVertex &path,
bool &exists) const;
@ -49,6 +49,7 @@ public:
const RiseFall *end_rf,
const MinMax *min_max,
PathVertex *path,
bool include_internal_latency,
StaState *sta);
private:
@ -61,7 +62,7 @@ private:
Delay insertion_[RiseFall::index_count][RiseFall::index_count][MinMax::index_count];
Delay delay_[RiseFall::index_count][RiseFall::index_count][MinMax::index_count];
float lib_clk_delay_[RiseFall::index_count][RiseFall::index_count][MinMax::index_count];
float internal_latency_[RiseFall::index_count][RiseFall::index_count][MinMax::index_count];
Delay latency_[RiseFall::index_count][RiseFall::index_count][MinMax::index_count];
PathVertex path_[RiseFall::index_count][RiseFall::index_count][MinMax::index_count];
bool exists_[RiseFall::index_count][RiseFall::index_count][MinMax::index_count];

47
search/ClkLatency.cc
View File

@ -40,20 +40,23 @@ ClkLatency::ClkLatency(StaState *sta) :
ClkDelays
ClkLatency::findClkDelays(const Clock *clk,
const Corner *corner)
const Corner *corner,
bool include_internal_latency)
{
ConstClockSeq clks;
clks.push_back(clk);
ClkDelayMap clk_delay_map = findClkDelays(clks, corner);
ClkDelayMap clk_delay_map = findClkDelays(clks, corner,
include_internal_latency);
return clk_delay_map[clk];
}
void
ClkLatency::reportClkLatency(ConstClockSeq clks,
const Corner *corner,
bool include_internal_latency,
int digits)
{
ClkDelayMap clk_delay_map = findClkDelays(clks, corner);
ClkDelayMap clk_delay_map = findClkDelays(clks, corner, include_internal_latency);
// Sort the clocks to report in a stable order.
ConstClockSeq sorted_clks;
@ -80,20 +83,20 @@ ClkLatency::reportClkLatency(const Clock *clk,
PathVertex path_min;
Delay insertion_min;
Delay delay_min;
float lib_clk_delay_min;
float internal_latency_min;
Delay latency_min;
bool exists_min;
clk_delays.delay(src_rf, end_rf, MinMax::min(), insertion_min,
delay_min, lib_clk_delay_min, latency_min,
delay_min, internal_latency_min, latency_min,
path_min, exists_min);
PathVertex path_max;
Delay insertion_max;
Delay delay_max;
float lib_clk_delay_max;
float internal_latency_max;
Delay latency_max;
bool exists_max;
clk_delays.delay(src_rf, end_rf, MinMax::max(), insertion_max,
delay_max, lib_clk_delay_max, latency_max,
delay_max, internal_latency_max, latency_max,
path_max, exists_max);
if (exists_min & exists_max) {
report_->reportLine("%s -> %s",
@ -112,11 +115,11 @@ ClkLatency::reportClkLatency(const Clock *clk,
"",
delayAsString(delay_max, this, digits),
sdc_network_->pathName(path_max.pin(this)));
if (lib_clk_delay_min != 0.0
|| lib_clk_delay_max != 0.0)
report_->reportLine("%7s %7s liberty clock tree delay",
time_unit->asString(lib_clk_delay_min, digits),
time_unit->asString(lib_clk_delay_max, digits));
if (internal_latency_min != 0.0
|| internal_latency_max != 0.0)
report_->reportLine("%7s %7s internal clock latency",
time_unit->asString(internal_latency_min, digits),
time_unit->asString(internal_latency_max, digits));
report_->reportLine("---------------");
report_->reportLine("%7s %7s latency",
delayAsString(latency_min, this, digits),
@ -132,7 +135,8 @@ ClkLatency::reportClkLatency(const Clock *clk,
ClkDelayMap
ClkLatency::findClkDelays(ConstClockSeq clks,
const Corner *corner)
const Corner *corner,
bool include_internal_latency)
{
ClkDelayMap clk_delay_map;
// Make entries for the relevant clocks to filter path clocks.
@ -159,7 +163,8 @@ ClkLatency::findClkDelays(ConstClockSeq clks,
bool exists;
clk_delays.latency(clk_rf, end_rf, min_max, clk_latency, exists);
if (!exists || delayGreater(latency, clk_latency, min_max, this))
clk_delays.setLatency(clk_rf, end_rf, min_max, path, this);
clk_delays.setLatency(clk_rf, end_rf, min_max, path,
include_internal_latency, this);
}
}
}
@ -176,7 +181,7 @@ ClkDelays::ClkDelays()
for (auto mm_index : MinMax::rangeIndex()) {
insertion_[src_rf_index][end_rf_index][mm_index] = 0.0;
delay_[src_rf_index][end_rf_index][mm_index] = 0.0;
lib_clk_delay_[src_rf_index][end_rf_index][mm_index] = 0.0;
internal_latency_[src_rf_index][end_rf_index][mm_index] = 0.0;
latency_[src_rf_index][end_rf_index][mm_index] = 0.0;
exists_[src_rf_index][end_rf_index][mm_index] = false;
}
@ -202,7 +207,7 @@ ClkDelays::delay(const RiseFall *src_rf,
path = path_[src_rf_index][end_rf_index][mm_index];
insertion = insertion_[src_rf_index][end_rf_index][mm_index];
delay = delay_[src_rf_index][end_rf_index][mm_index];
lib_clk_delay = lib_clk_delay_[src_rf_index][end_rf_index][mm_index];
lib_clk_delay = internal_latency_[src_rf_index][end_rf_index][mm_index];
latency = latency_[src_rf_index][end_rf_index][mm_index];
exists = exists_[src_rf_index][end_rf_index][mm_index];
}
@ -227,6 +232,7 @@ ClkDelays::setLatency(const RiseFall *src_rf,
const RiseFall *end_rf,
const MinMax *min_max,
PathVertex *path,
bool include_internal_latency,
StaState *sta)
{
int src_rf_index = src_rf->index();
@ -239,10 +245,13 @@ ClkDelays::setLatency(const RiseFall *src_rf,
float delay1 = delay(path, sta);
delay_[src_rf_index][end_rf_index][mm_index] = delay1;
float lib_clk_delay = clkTreeDelay(path, sta);
lib_clk_delay_[src_rf_index][end_rf_index][mm_index] = lib_clk_delay;
float internal_latency = 0.0;
if (include_internal_latency) {
internal_latency = clkTreeDelay(path, sta);
internal_latency_[src_rf_index][end_rf_index][mm_index] = internal_latency;
}
float latency = insertion + delay1 + lib_clk_delay;
float latency = insertion + delay1 + internal_latency;
latency_[src_rf_index][end_rf_index][mm_index] = latency;
path_[src_rf_index][end_rf_index][mm_index] = *path;

7
search/ClkLatency.hh
View File

@ -37,13 +37,16 @@ public:
// Report clk latency for clks.
void reportClkLatency(ConstClockSeq clks,
const Corner *corner,
bool include_internal_latency,
int digits);
ClkDelays findClkDelays(const Clock *clk,
const Corner *corner);
const Corner *corner,
bool include_internal_latency);
protected:
ClkDelayMap findClkDelays(ConstClockSeq clks,
const Corner *corner);
const Corner *corner,
bool include_internal_latency);
void reportClkLatency(const Clock *clk,
ClkDelays &clk_delays,
int digits);

2
search/MakeTimingModel.cc
View File

@ -548,7 +548,7 @@ MakeTimingModel::findClkInsertionDelays()
size_t clk_count = clks->size();
if (clk_count == 1) {
for (const Clock *clk : *clks) {
ClkDelays delays = sta_->findClkDelays(clk);
ClkDelays delays = sta_->findClkDelays(clk, true);
for (const MinMax *min_max : MinMax::range()) {
makeClkTreePaths(lib_port, min_max, TimingSense::positive_unate, delays);
makeClkTreePaths(lib_port, min_max, TimingSense::negative_unate, delays);

8
search/Sta.cc
View File

@ -2634,19 +2634,21 @@ Sta::clkSkewPreamble()
void
Sta::reportClkLatency(ConstClockSeq clks,
const Corner *corner,
bool include_internal_latency,
int digits)
{
ensureClkArrivals();
ClkLatency clk_latency(this);
clk_latency.reportClkLatency(clks, corner, digits);
clk_latency.reportClkLatency(clks, corner, include_internal_latency, digits);
}
ClkDelays
Sta::findClkDelays(const Clock *clk)
Sta::findClkDelays(const Clock *clk,
bool include_internal_latency)
{
ensureClkArrivals();
ClkLatency clk_latency(this);
return clk_latency.findClkDelays(clk, nullptr);
return clk_latency.findClkDelays(clk, nullptr, include_internal_latency);
}
////////////////////////////////////////////////////////////////

7
tcl/Search.tcl
View File

@ -356,13 +356,15 @@ proc_redirect report_clock_skew {
define_cmd_args "report_clock_latency" {[-clock clocks]\
[-corner corner]\
[-include_internal_latency]
[-digits digits]}
proc_redirect report_clock_latency {
global sta_report_default_digits
parse_key_args "report_clock_" args \
keys {-clock -corner -digits} flags {}
keys {-clock -corner -digits} \
flags {-include_internal_latency}
check_argc_eq0 "report_clock_latency" $args
if [info exists keys(-clock)] {
@ -371,6 +373,7 @@ proc_redirect report_clock_latency {
set clks [all_clocks]
}
set corner [parse_corner_or_all keys]
set include_internal_latency [info exists flags(-include_internal_latency)]
if [info exists keys(-digits)] {
set digits $keys(-digits)
check_positive_integer "-digits" $digits
@ -378,7 +381,7 @@ proc_redirect report_clock_latency {
set digits $sta_report_default_digits
}
if { $clks != {} } {
report_clk_latency $clks $corner $digits
report_clk_latency $clks $corner $include_internal_latency $digits
}
}

3
tcl/StaTcl.i
View File

@ -3051,10 +3051,11 @@ report_clk_skew(ConstClockSeq clks,
void
report_clk_latency(ConstClockSeq clks,
const Corner *corner,
bool include_internal_latency,
int digits)
{
cmdLinkedNetwork();
Sta::sta()->reportClkLatency(clks, corner, digits);
Sta::sta()->reportClkLatency(clks, corner, include_internal_latency, digits);
}
float