TDEB Top Bar

Trending
Semiconductor Industry News — The Digital Electronics Blog
Follow Us

TDEB Masthead

The Semiconductor Hub

Semiconductors.  Chips and Systems.  Innovation.

Indexed by leading Search Engines, AI and referenced by Engineers worldwide 500+ Articles 10M+ Pageviews 30+ Reports 50+ Citations

Reading Real Reports, Part 2: The STA Timing Path Report, Line by Line

The Semiconductor Hub
by
0
Share Facebook X LinkedIn WhatsApp Email
Excerpt of an OpenSTA-style setup timing path report showing clock network delay, arrival time, required time and a violated slack.

The timing path report is the report every digital engineer meets first, and the one most people read backwards. They jump to the last line, see a slack number, and start fixing. A senior reads it top to bottom, because the header and the clock lines decide whether the slack at the bottom means anything.

This is Part 2 of Reading Real Reports. Yesterday we covered the five questions to ask before opening any report. Today we take one setup path report in the format printed by the open-source OpenSTA timer and read every line of it, with the arithmetic checked by hand.

Key takeaways

  • A path report has three parts: a header, the data path (arrival time) and the capture clock path (required time). Slack is required minus arrival for a setup check.
  • Read the header first. Path Type and Corner tell you which check and which conditions you are looking at.
  • Read the clock lines second. Ideal clocks, a wrong capture edge or a large uncertainty change the answer more than any gate on the path.
  • Look for the biggest increments, not the longest list of cells. One slow stage usually explains most of a violation.
  • The report shows one path per group by default. The worst path is rarely the only one.

In this post

What the path report is

A static timing tool checks every path from a startpoint (a flip-flop or an input port) to an endpoint (another flip-flop or an output port). The path report prints one of those paths in full. The UC Santa Cruz STA tutorial describes it the same way: each report goes from a startpoint to an endpoint, and a rising transition is marked ^ while a falling one is marked v (Max paths).

The idea behind the numbers is simple. Data leaves the launching flop after one clock edge and must reach the capturing flop a little before the next edge. The report adds up when the data actually arrives, works out when it is required, and subtracts.

When you see it

In OpenSTA and OpenROAD the command is report_checks. You see its output after synthesis, after placement, after clock tree synthesis and at sign-off. The OpenROAD-flow-scripts tutorial shows it while fixing a setup violation, run as report_checks -fields input -digits 3 (Fixing Setup Violations). Commercial timers print a similar report with different labels, so the reading habits below carry over.

What a senior checks first

  1. Which check, which corner. Path Type: max is a setup check; min is hold, as the -path_delay option defines. A setup path should come from a slow corner.
  2. The clock lines. Is the clock network delay ideal or propagated? Is the capture edge one period after the launch edge, or has an exception moved it?
  3. Where the time goes. Scan the Delay column for the two or three largest numbers. That is where a fix will come from.
  4. What the capture side takes away. Setup time, clock uncertainty and any skew all shrink the time available. Sometimes the data path is fine and the budget is the problem.
  5. How many paths look like this. One report is one path. Ask for more before you plan the fix.

Common traps

  • Trusting a pre-CTS report. With ideal clocks there is no skew, so the result after clock tree synthesis can move either way.
  • Fixing the printed path only. By default the report shows one path per path group (-group_path_count, default 1). Ten other endpoints may fail by almost the same amount.
  • Reading wire delay as cell delay. In the default format each output pin line folds in the wire before it. Add -fields input_pin to see input pins on their own lines, as the UC Santa Cruz tutorial explains (Path detail options).
  • Ignoring the edge marks. Rise and fall delays differ. A path that fails only on the falling edge needs a different fix.

Deep dive: the numbers and details

This part holds the full sample report, a reading of each line, the arithmetic and the checklists. Skip it if the overview is all you need.

The illustrative sample

The report below is an illustrative sample in the style of OpenSTA/OpenROAD report_checks output, written for this post. Instance names, cell names, the corner name and every number are invented. The line labels follow public examples in the OpenROAD-flow-scripts tutorial and the UC Santa Cruz reporting tutorial. Units are nanoseconds.

Startpoint: u_ctrl/state_reg_2_ (rising edge-triggered flip-flop clocked by core_clk)
Endpoint: u_dp/acc_reg_15_ (rising edge-triggered flip-flop clocked by core_clk)
Path Group: core_clk
Path Type: max
Corner: ss_0p72v_125c

  Delay    Time   Description
---------------------------------------------------------
   0.00    0.00   clock core_clk (rise edge)
   0.38    0.38   clock network delay (propagated)
   0.00    0.38 ^ u_ctrl/state_reg_2_/CK (DFFR_X1)
   0.21    0.59 v u_ctrl/state_reg_2_/Q (DFFR_X1)
   0.09    0.68 ^ u_ctrl/U112/ZN (INV_X2)
   0.14    0.82 v u_dp/U507/ZN (NAND2_X1)
   0.27    1.09 ^ u_dp/U611/ZN (AOI21_X1)
   0.18    1.27 ^ u_dp/U612/Z (BUF_X4)
   0.31    1.58 ^ u_dp/add_45/U9/S (FA_X1)
   0.06    1.64 ^ u_dp/acc_reg_15_/D (DFFR_X1)
           1.64   data arrival time

   1.25    1.25   clock core_clk (rise edge)
   0.35    1.60   clock network delay (propagated)
  -0.06    1.54   clock uncertainty
   0.02    1.56   clock reconvergence pessimism
           1.56 ^ u_dp/acc_reg_15_/CK (DFFR_X1)
  -0.08    1.48   library setup time
           1.48   data required time
---------------------------------------------------------
           1.48   data required time
          -1.64   data arrival time
---------------------------------------------------------
          -0.16   slack (VIOLATED)

Line-by-line walk-through

Header.

  • Startpoint and Endpoint name the launching and capturing flops, and the text in brackets says what kind of element each is and which clock drives it. Both use core_clk, so this is a single-clock path.
  • Path Group: core_clk. OpenSTA groups paths by capture clock, plus groups for unclocked, gated-clock and unconstrained paths (report_checks). The UC Santa Cruz example also shows an asynchronous group for a reset recovery check.
  • Path Type: max. A setup check.
  • Corner: ss_0p72v_125c. The analysis corner. A slow, low-voltage, hot corner is the right place for setup.

Columns. Delay is the increment for that line. Time is the running total. The symbol before the pin name is the edge at that pin.

Launch side (arrival).

  • clock core_clk (rise edge) at 0.00 is the launch edge.
  • clock network delay (propagated), 0.38. The clock takes 0.38 ns through the clock tree to reach the launching flop. "Propagated" means real buffer and wire delays are used; with ideal clocks this line says (ideal) and is usually 0, as in the tutorial example. The OpenSTA command that switches a clock to propagated is set_propagated_clock.
  • CK at 0.38, then Q at 0.59. Clock-to-output delay of 0.21 ns. Q falls here.
  • Four gates follow. Note the edges flip through the inverting cells (INV, NAND, AOI) and hold through the buffer and the adder sum output.
  • The last line, D at 1.64, has an increment of 0.06 with no cell of its own. That is the wire from the adder to the flop input.
  • data arrival time 1.64. When the data settles at D.

Capture side (required).

  • clock core_clk (rise edge) at 1.25. The next rising edge, one period later. A different number here means a multicycle path, a different capture clock or a half-cycle path.
  • clock network delay (propagated), 0.35. The capture flop gets its clock 0.35 ns after the edge, 0.03 ns earlier than the launch flop did.
  • clock uncertainty, minus 0.06. Margin for jitter and other effects, set with set_clock_uncertainty. That command can set separate values for setup and hold.
  • clock reconvergence pessimism, plus 0.02. Launch and capture clocks share part of the clock tree. The timer uses late delays on one side and early delays on the other, but a shared buffer cannot be early and late at the same time, so this credit gives some time back. The TAU 2014 timing contest was built around removing exactly this kind of pessimism from the early and late split (TAU 2014 Contest: Common Path Pessimism Removal).
  • library setup time, minus 0.08. From the flop's Liberty model. It depends on the slews at D and CK, so it is not a fixed number for a cell.
  • data required time 1.48. The latest time data may arrive.

Footer. Required 1.48 minus arrival 1.64 gives minus 0.16, so the check is VIOLATED.

Worked arithmetic check

Arrival. 0.00 + 0.38 + 0.21 + 0.09 + 0.14 + 0.27 + 0.18 + 0.31 + 0.06 = 1.64 ns. It matches the report.

Required. 1.25 + 0.35 - 0.06 + 0.02 - 0.08 = 1.48 ns. It matches.

Slack. slack = required - arrival = 1.48 - 1.64 = -0.16 ns.

The budget view. Seniors often rewrite the same numbers as a budget for the data path from CK to D:

available = period - setup - uncertainty + (capture latency - launch latency) + CRPR
          = 1.25 - 0.08 - 0.06 + (0.35 - 0.38) + 0.02
          = 1.10 ns
used      = arrival at D - clock at launch CK = 1.64 - 0.38 = 1.26 ns
slack     = 1.10 - 1.26 = -0.16 ns

Same answer, but now you can see that the capture side takes 0.15 ns (setup, uncertainty and the 0.03 ns of unhelpful skew) and gives back 0.02 ns.

Where the time goes. Of the 1.26 ns used, the adder stage (0.31), the AOI21 (0.27) and the flop's clock-to-Q (0.21) take 0.79 ns, about 63 percent. An AOI21 at 0.27 ns next to a NAND2 at 0.14 ns is worth a closer look: rerun with -fields slew capacitance fanout (-fields) to see whether it drives a heavy load or receives a slow input.

What clock would pass? With every other number fixed, the period must grow by 0.16 ns to 1.41 ns, about 709 MHz instead of 800 MHz. OpenSTA's report_clock_min_period reports this kind of figure directly, with listed limits on which paths it considers.

Red flags table

Line or patternWhy it is a red flagNext step
clock network delay (ideal) after clock tree synthesisSkew and real latency are missingCheck that the clock is set to propagated
Capture edge not one period after launchAn exception or clock relation changed the checkFind the SDC line that caused it
One increment far larger than its neighborsLong wire, high fanout or a weak cellRerun with -fields slew, capacitance and fanout
Large library setup timeOften a slow slew at D or CKLook at the transition into the flop
Path Type max at a fast cornerSetup checked where it is least likely to failConfirm the corner list
Same startpoint in every top pathOne logic cone or one placement problemReport more paths with -endpoint_path_count and group them

Sign-off checklist

  • Path Type and Corner match the check you meant to review.
  • Clocks are propagated for any post-CTS result.
  • Launch and capture edges are where the clock definition says they should be.
  • Arrival and required times re-add by hand to within rounding.
  • The largest increments are named, with a cause for each.
  • Uncertainty and setup time are known values, not surprises.
  • More than one path per group has been reviewed before the fix is chosen.
  • TNS, not only WNS, is known for the group (see the UC Santa Cruz notes on report_tns).

Next in the series: Setup vs Hold Paths and Why the Same Path Tells Two Stories.

Share Facebook X LinkedIn WhatsApp Email

Post a Comment

0 Comments

Your comments will be moderated before it appears here.

Post a Comment (0)

#buttons=(Ok, Go it!) #days=(20)

Our website uses cookies to enhance your experience. Learn more
Ok, Go it!