Skip to content
DenseChip
Learn
PracticeCode labInterview

DenseChip

Navigate

Menu

LearnPracticeCode labInterview

Tools

All toolsSV editorCode repoResume
DenseChip

Practice, courses, and chip-design tools in one focused workspace.

LearnPracticeCode labInterviewToolsLearning paths

© 2026 DenseChip

AboutContactPrivacyTerms
Skip to lesson

Course contents

  • RTL Foundations36
  • Combinational Design25
  • Sequential Design27
  • FSM & Control27
  • Timing & Clocking39
    • STA Foundations
      • Where RTL Meets STA
      • Canonical STA Flow
      • Corners
      • SDC Starter Set
      • Why RTL Architecture Dominates
    • Setup, Hold and Slack
    • Skew and Variation
    • Timing Exceptions
    • Clock Gating
    • RTL for Timing
    • Clock Architecture
  • Reset & CDC34
  • Memory & Buses57
  • Advanced RTL28
  • Senior & Interview76
  • Glossary and Notation
Loading lesson

‹STA Foundations
  1. Topics
  2. RTL Design
  3. Timing & Clocking
  4. STA Foundations
  5. Where RTL Meets STA

Part 5 · Timing & Clocking · Intermediate

Where RTL Meets STA

Timing paths, startpoints and endpoints, and early logic depth estimates.

On this page

    Why this matters

    Timing fails in the paths your RTL creates, long before a tool reports it. Counting logic levels in the longest path gives an early warning, but only if you know that levels are not nanoseconds.

    After this lesson you can: name the startpoint and endpoint of each kind of timing path, say what RTL features set a path's contents, and estimate logic depth before running a tool.

    Every path has a start and an end

    STA breaks the design into timing paths. Each path runs from a startpoint to an endpoint.

    A startpoint is a flip-flop clock pin or an input port. An endpoint is a flip-flop data pin or an output port.

    Combinational logic and wire sit in between.

    Path type

    Startpoint

    Endpoint

    Governed by

    Register to register

    Flip-flop clock pin

    Flip-flop D pin

    The clock period

    Input to register

    Input port

    Flip-flop D pin

    set_input_delay

    Register to output

    Flip-flop clock pin

    Output port

    set_output_delay

    Input to output

    Input port

    Output port

    Both input and output delays (a purely combinational feed-through)

    Input to register, register to register, and register to output paths.
    Three path segments. Each one is checked separately against its own clock edge and constraint.

    What STA reads from RTL

    RTL structure sets what each path contains. The table lists the main effects.

    RTL feature

    Effect on timing

    Registers between logic

    Cut the design into paths. More registers mean shorter paths.

    Combinational depth between registers

    Directly sets path delay.

    Fanout of a signal

    More loads mean slower transitions and extra buffers.

    Muxes and enables on D inputs

    Add logic in front of every register.

    Combinational feed-through from input to output

    Creates input-to-output paths that most designs prefer to avoid.

    Multiple clocks

    Paths between clocks need explicit handling (CDC and exceptions).

    Estimating depth before running a tool

    A quick proxy is the longest topological path in the flattened combinational graph. Yosys ltp -noff excludes flip-flop cells; it does not select only register-to-register paths. An output-only registered adder can instead have an input-port-to-register-D path. Inspect the printed start/end nets and map them back to ports or register pins.

    For a bounded experiment, save the design modules (exclude tb_ks) and the two matching measurement tops from Architecture dominates as design.sv. Both tops register inputs and outputs; their arithmetic path is from ra/rb Q to the output register D (y in the plain top, u.r in the prefix top). Record the source revision, Yosys version, bundled ABC version/banner and complete logs for both fresh runs:

    Diagram
    yosys -V
    yosys -p "read_verilog -sv design.sv; synth -top measure_plain -flatten -noabc; abc -g AND,OR,XOR,MUX; stat; ltp -noff"
    yosys -p "read_verilog -sv design.sv; synth -top measure_prefix -flatten -noabc; abc -g AND,OR,XOR,MUX; stat; ltp -noff"

    Design (registered output)

    Levels in the longest path

    8-bit adder

    15

    16-bit adder

    31

    32-bit adder

    63

    32-bit comparator (a < b)

    20

    8×8 multiplier

    30

    8×8 multiply-add (a*b + c)

    33

    These are generic-flow counts. The commands above define a comparison with explicit tops, and another tool version can give different counts. Generic cells are not library area, and levels are not nanoseconds. Real tools use a cell library with timing-driven optimisation.

    The reported adder counts grow roughly linearly with width in that mapping. The + operator does not require ripple carry; another mapper, library or timing target can choose a different carry structure. See the Yosys ltp reference for the command's graph scope.

    Common mistakes

    Common pitfall

    Counting levels ignores wire delay and fanout. A path with 10 levels and a fanout of 200 on one net can be slower than a path with 20 levels and small fanouts. Use depth as an early warning, and always confirm with real STA.

    Check yourself A design has a clock period of 2 ns and, as an assumption, each gate level costs about 0.1 ns (generic levels are not nanoseconds). Roughly how many levels fit between registers, assuming 0.5 ns for clock-to-Q plus setup?

    About (2.0 − 0.5) / 0.1 = 15 levels under that assumed cost; real cell and wire delays change the number. The 8-bit adder above (15 levels) just fits; the 16-bit adder (31 levels) would need to be restructured or pipelined.

    Remember

    • A path runs from a flip-flop clock pin or an input port to a flip-flop data pin or an output port.

    • Yosys ltp -noff finds the longest combinational path. Inspect its start and end nets, because it is not limited to register-to-register paths.

    • Levels ignore wire delay and fanout, so a path with fewer levels can still be slower.

    Rule of thumb: use depth as an early warning, and confirm it with real timing.

    How this was checked

    The level counts in the table are historical generic-flow counts. The original source bundle and tool and ABC versions were not recorded. Only the 32-bit adder row was re-run (Yosys 0.69, 2026-10-16, measure_plain), and it gives 63 levels, matching the table.

    Keep going

    • Interview: run a mock interview on this topic

    Related topics

    • Canonical STA flow

    Previous

    116 / 350

    Next: Canonical STA Flow

    Up next

    Up nextCanonical STA Flow

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Corners
    • SDC Starter Set
    • Why RTL Architecture Dominates