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. Canonical STA Flow

Part 5 · Timing & Clocking · Intermediate

Canonical STA Flow

The steps of a timing run and the reports that guide RTL fixes.

On this page

    Why this matters

    A clean timing report is only as trustworthy as the SDC behind it. Registers with no clock are not timed at all, so a missing create_clock makes the report look better than the chip.

    After this lesson you can: run through the seven steps of a timing run, read WNS and TNS together, and fix negative slack in the right order.

    A timing run in one picture

    A timing run reads four inputs, checks that the constraints cover the design, computes arrival and required times, and reports slack.

    Libraries, netlist, SDC and parasitics feed a read step, followed by a constraint check, a timing update and the slack report.
    A timing run: four inputs are read, the constraints are checked, arrival and required times are computed, and slack is reported per path, endpoint and clock group.

    Read it top to bottom. Each box is one step of the run.

    • Libraries hold cell delay and constraint tables for one corner (process, voltage, temperature).

    • Netlist is the synthesized design, or the placed-and-routed design later in the flow. SDC gives clocks, input and output delays and exceptions.

    • Parasitics are wire resistance and capacitance after placement and routing. Before that, a wire-load estimate is used.

    • Check constraints asks: are all registers clocked? Any unconstrained endpoints? Any combinational loops? Update timing then computes arrival times at every pin and required times at every endpoint.

    One report line, annotated

    The report lists each endpoint with its slack. This constructed summary has three endpoints in one clock group, with a 2.00 ns clock and 0.12 ns setup.

    Diagram
    Endpoint               Clock  Required  Arrival   Slack
    u_alu/acc_reg[7]/D     clk      1.88      1.93    -0.05  (VIOLATED)
    u_alu/acc_reg[6]/D     clk      1.88      1.89    -0.01  (VIOLATED)
    u_ctl/state_reg[0]/D   clk      1.88      1.68    +0.20  (MET)
    • Required is when data must be there: the next edge minus setup and uncertainty. Here 2.00 - 0.12 = 1.88 ns, with no uncertainty.

    • Arrival is when the latest data actually gets there: clock-to-Q plus logic and wire.

    • Slack is required minus arrival. Negative means the endpoint fails by that much.

    • The summary of these three lines is WNS -0.05 ns (the worst) and TNS -0.06 ns (the sum of the two negative slacks).

    Reports from a timing run

    Each report answers one question. The table lists the main ones.

    Report

    Question it answers

    Constraint check (unclocked registers, missing delays)

    Is every path actually being timed?

    Worst paths by group

    Which paths limit the clock?

    Setup (max) and hold (min) reports

    Do any endpoints fail either check?

    Timing summary (WNS, TNS)

    How bad is it overall? WNS = worst negative slack, TNS = total negative slack.

    Clock network and skew reports

    How well balanced is the clock?

    Fixing negative slack

    Work from constraints to structure. The list below gives the order.

    • First make sure the constraints are right; an over-tight or missing constraint wastes days.

    • Then look at the worst path: its startpoint, endpoint, the number of logic levels, the largest fanout on the path, and whether clock skew helps or hurts.

    • Group failing paths by cause. Hundreds of failing endpoints are often one slow module.

    • Fix structurally in RTL when the cause is depth or fanout; use tool optimisation for the small remainder.

    Common mistakes

    Tip

    Look at WNS and TNS together, after checking the tool's aggregation convention and report group/view. For a summary that sums each violating endpoint's worst slack once, endpoint slacks {-0.05, -0.01, +0.20} ns give WNS -0.05 and TNS -0.06 ns: two failing endpoints, potentially sharing one cause. With WNS -0.05 and TNS -80 ns, at least 1600 negative endpoint contributions are needed under that convention. Neither summary counts distinct physical paths or root causes; inspect endpoint counts, groups and common logic.

    Common pitfall

    Constraints are code. A wrong create_clock period or a missing clock on one block makes the report look better or worse than reality. Treat the report as only as trustworthy as the SDC behind it.

    Check yourself STA reports no failing paths, but the constraint check says 300 registers are unclocked. Is the design clean?

    No. Unclocked registers are not timed at all, so their paths are missing from the report. Fix the clock definition and rerun before trusting the result.

    Remember

    • A run reads libraries, netlist, constraints and parasitics, checks the constraints, updates timing and reports slack.

    • Check the constraints first, then the worst path, then group failing paths by cause. Hundreds of failures are often one slow module.

    • Fix depth and fanout structurally in RTL. Use tool optimisation for the small remainder.

    Rule of thumb: treat constraints as code, and read the unconstrained-endpoint report before trusting a clean summary.

    Keep going

    • Interview: run a mock interview on this topic

    Related topics

    • Corners

    Previous

    117 / 350

    Next: Corners

    Up next

    Up nextCorners

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • SDC Starter Set
    • Why RTL Architecture Dominates